Guide

Guia de formato ISO 8601: padrão de data, hora e fuso horário

O que é ISO 8601?

ISO 8601 é um padrão internacional para representar datas e horas em um formato claro e inequívoco. Publicado pela Organização Internacional de Normalização (ISO), este padrão elimina a confusão causada por diferentes formatos de data em todo o mundo (como MM/DD/AAAA vs DD/MM/AAAA) e fornece uma maneira consistente de trocar informações de data e hora.

O formato ISO 8601 é amplamente utilizado em APIs, bancos de dados e aplicações web porque:

Inequívoco: Sem confusão sobre a ordem de dia/mês
Classificável: a classificação lexicográfica funciona corretamente
Legível por máquina: fácil para os computadores analisarem
Legível por humanos: ainda compreensível pelas pessoas
Universal: funciona em todos os fusos horários e localidades

Por que usar o formato ISO 8601?

Quando você vê uma data como 03/04/2024, isso significa 4 de março ou 3 de abril? Diferentes países interpretam isso de maneira diferente. A ISO 8601 resolve esse problema usando o formato 2024-04-03, que é sempre inequívoco: ano-mês-dia.

// Ambiguous formats (avoid these)
"03/04/2024"  // Is this March 4 or April 3?
"4-3-24"      // Is this 2024 or 1924?

// ISO 8601 format (recommended)
"2024-04-03"  // Always April 3, 2024
"2024-04-03T14:30:00Z"  // April 3, 2024, 2:30 PM UTC

Formatos de data ISO 8601

Formato Básico de Data

O formato de data ISO 8601 padrão segue o padrão: AAAA-MM-DD

Exemplos:

2024-01-15 - 15 de janeiro de 2024
2024-12-31 - 31 de dezembro de 2024
2025-06-07 - 7 de junho de 2025

# Python example
from datetime import date

today = date(2024, 4, 15)
iso_date = today.isoformat()  # "2024-04-15"
print(f"ISO 8601 date: {iso_date}")

Formato Estendido vs Básico

ISO 8601 oferece suporte a dois formatos:

Formato estendido (com separadores): 2024-04-15
Formato básico (compacto): 20240415

A maioria dos aplicativos usa o formato estendido porque é mais legível.

// JavaScript example
const date = new Date('2024-04-15');

// Extended format (recommended)
const extended = date.toISOString().split('T')[0];  // "2024-04-15"

// Basic format (compact)
const basic = extended.replace(/-/g, '');  // "20240415"

Datas da Semana

ISO 8601 também oferece suporte a datas baseadas em semanas usando o formato: AAAA-Www-D

AAAA: Ano
Www: Número da semana (01-53)
D: Dia da semana (1=segunda-feira, 7=domingo)

Exemplo: 2024-W15-3 significa quarta-feira da semana 15 em 2024.

Datas ordinais

Você também pode usar datas ordinais (dia do ano): AAAA-DDD

Exemplo: 2024-366 significa 31 de dezembro de 2024 (ano bissexto, portanto 366 dias).

Formatos de hora ISO 8601

Formato Básico de Hora

O formato de hora ISO 8601 padrão é o seguinte: HH:MM:SS ou HH:MM:SS.sss

Exemplos:

14:30:00 - 14:30:00
09:05:30 - 9:05:30 AM
23:59:59.999 - 23:59:59.999 PM com milissegundos

// Java example
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

LocalTime time = LocalTime.of(14, 30, 0);
String isoTime = time.format(DateTimeFormatter.ISO_LOCAL_TIME);
System.out.println("ISO 8601 time: " + isoTime);  // "14:30:00"

Segundos Fracionários

ISO 8601 oferece suporte a segundos fracionários com precisão variável:

14:30:00.5 - Meio segundo
14:30:00.123 - Milissegundos (3 dígitos)
14:30:00.123456 - Microssegundos (6 dígitos)
14:30:00.123456789 - Nanossegundos (9 dígitos)

// Go example
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    // ISO 8601 with milliseconds
    iso := now.Format("15:04:05.000")
    fmt.Println("ISO 8601 time:", iso)
}

Formatos de data e hora ISO 8601

Data e hora combinadas

Para representar data e hora, ISO 8601 usa um separador T: AAAA-MM-DDTHH:MM:SS

Exemplos:

2024-04-15T14:30:00 - 15 de abril de 2024 às 14h30 (horário local)
2024-12-31T23:59:59 - 31 de dezembro de 2024 às 23h59:59

# Ruby example
require 'time'

datetime = Time.new(2024, 4, 15, 14, 30, 0)
iso_datetime = datetime.iso8601  # "2024-04-15T14:30:00+00:00"
puts "ISO 8601 datetime: #{iso_datetime}"

O separador "T"

O caractere T separa a data da hora. É necessário no formato padrão, embora alguns sistemas aceitem um espaço para facilitar a leitura.

// PHP example
<?php
$datetime = new DateTime('2024-04-15 14:30:00');
$iso8601 = $datetime->format('c');  // "2024-04-15T14:30:00+00:00"
echo "ISO 8601 datetime: " . $iso8601;
?>

Designadores de fuso horário ISO 8601

Um dos recursos mais poderosos da ISO 8601 é o suporte para informações de fuso horário.

Hora UTC (Designador Z)

O sufixo Z indica UTC (Tempo Universal Coordenado), também chamado de "horário Zulu":

2024-04-15T14:30:00Z - 14h30 UTC

Z é uma abreviação de +00:00.

// JavaScript example
const utcDate = new Date('2024-04-15T14:30:00Z');
console.log(utcDate.toISOString());  // "2024-04-15T14:30:00.000Z"

// Always prefer ISO 8601 with Z for UTC times
const timestamp = Date.now();
const isoString = new Date(timestamp).toISOString();
console.log(isoString);  // "2024-04-15T14:30:00.123Z"

Compensações de fuso horário

Para horários não UTC, especifique o deslocamento do UTC: ±HH:MM

Exemplos:

2024-04-15T14:30:00+05:30 - 14h30 na Índia (UTC+5:30)
2024-04-15T14:30:00-04:00 - 14h30 no horário de verão do leste (UTC-4)
2024-04-15T14:30:00+00:00 - Igual a Z (UTC)

# Python example with timezone
from datetime import datetime, timezone, timedelta

# UTC time
utc_time = datetime(2024, 4, 15, 14, 30, 0, tzinfo=timezone.utc)
print(utc_time.isoformat())  # "2024-04-15T14:30:00+00:00"

# Custom timezone (UTC+5:30)
ist = timezone(timedelta(hours=5, minutes=30))
ist_time = datetime(2024, 4, 15, 14, 30, 0, tzinfo=ist)
print(ist_time.isoformat())  # "2024-04-15T14:30:00+05:30"

Hora local (sem designador)

Se nenhum fuso horário for especificado, a hora será considerada hora local:

2024-04-15T14:30:00 - 14h30 no fuso horário local

Aviso: Evite usar horário local em APIs e bancos de dados. Sempre especifique o fuso horário para evitar ambiguidades.

Formato de duração ISO 8601

ISO 8601 define uma notação específica para durações usando o prefixo P (para "período").

Formato de duração: P[n]Y[n]M[n]DT[n]H[n]M[n]S

P: Designador de duração (obrigatório)
Y: Anos
M: Meses (antes de T)
D: Dias
T: Designador de tempo (separa a data dos componentes de tempo)
H: Horas
M: Minutos (após T)
S: Segundos

Exemplos de duração

P3Y6M4DT12H30M5S  = 3 years, 6 months, 4 days, 12 hours, 30 minutes, 5 seconds
P1Y               = 1 year
P6M               = 6 months
P7D               = 7 days
PT2H30M           = 2 hours, 30 minutes
PT45S             = 45 seconds
P1DT12H           = 1 day, 12 hours
P0D               = 0 days (zero duration)

// JavaScript example (using date-fns or custom parsing)
function parseISO8601Duration(duration) {
    const regex = /P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?/;
    const matches = duration.match(regex);

    return {
        years: parseInt(matches[1]) || 0,
        months: parseInt(matches[2]) || 0,
        days: parseInt(matches[3]) || 0,
        hours: parseInt(matches[4]) || 0,
        minutes: parseInt(matches[5]) || 0,
        seconds: parseInt(matches[6]) || 0
    };
}

const duration = parseISO8601Duration("P1DT2H30M");
console.log(duration);  // { years: 0, months: 0, days: 1, hours: 2, minutes: 30, seconds: 0 }

Duração da semana

Você também pode expressar durações em semanas usando W:

P3W = 3 semanas (equivalente a P21D)

Intervalos de tempo ISO 8601

ISO 8601 oferece suporte a três maneiras de expressar intervalos de tempo:

1. Horários de início e término

<início>/<fim>

Exemplo: 2024-04-15T09:00:00Z/2024-04-15T17:00:00Z (9h às 17h UTC)

2. Hora de início e duração

<início>/P<duração>

Exemplo: 2024-04-15T09:00:00Z/PT8H (9h UTC por 8 horas)

3. Duração e horário de término

P<duração>/<fim>

Exemplo: PT8H/2024-04-15T17:00:00Z (8 horas terminando às 17h UTC)

# Python example for intervals
from datetime import datetime, timedelta

start = datetime(2024, 4, 15, 9, 0, 0)
end = datetime(2024, 4, 15, 17, 0, 0)

# Calculate duration
duration = end - start
print(f"Duration: {duration}")  # 8:00:00

# ISO 8601 interval
interval = f"{start.isoformat()}/{end.isoformat()}"
print(f"Interval: {interval}")

ISO 8601 x RFC 3339

RFC 3339 é um perfil da ISO 8601 comumente usado na Internet. As principais diferenças:

Recurso	ISO 8601	RFC 3339
Formato	`AAAA-MM-DDTHH:MM:SS±HH:MM`	Mesmo
UTC	`Z` ou `+00:00`	Ambos permitidos
Segundos fracionários	Opcional, qualquer precisão	Opcional, qualquer precisão
Separadores	Pode ser omitido (formato básico)	Obrigatório (formato estendido)
Separador de tempo	`T` obrigatório	`T` ou espaço permitido

Exemplo:

ISO 8601: 2024-04-15T14:30:00Z ou 20240415T143000Z
RFC 3339: 2024-04-15T14:30:00Z (somente formato estendido)

A maioria das APIs modernas usa RFC 3339, que é um subconjunto estrito da ISO 8601.

Práticas recomendadas ISO 8601 para desenvolvedores

1. Sempre use UTC para armazenamento

Armazene todos os carimbos de data/hora em UTC com o designador Z:

// ✅ Good - Store in UTC
const timestamp = new Date().toISOString();  // "2024-04-15T14:30:00.123Z"

// ❌ Bad - Storing local time
const localTime = new Date().toString();  // "Mon Apr 15 2024 14:30:00 GMT+0500"

2. Incluir informações de fuso horário

Ao exibir horários, sempre inclua informações de fuso horário:

# ✅ Good - Includes timezone
"2024-04-15T14:30:00+05:30"

# ❌ Bad - Missing timezone
"2024-04-15T14:30:00"

3. Use formato estendido

Prefira o formato estendido (com separadores) para facilitar a leitura:

// ✅ Good - Extended format
"2024-04-15T14:30:00Z"

// ❌ Bad - Basic format (hard to read)
"20240415T143000Z"

4. Precisão é importante

Use a precisão apropriada para seu caso de uso:

// High precision for logging
"2024-04-15T14:30:00.123456789Z"

// Standard precision for most applications
"2024-04-15T14:30:00Z"

// Date only when time doesn't matter
"2024-04-15"

5. Validar strings ISO 8601

Sempre valide strings ISO 8601 antes de analisar:

// JavaScript validation
function isValidISO8601(dateString) {
    const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
    if (!iso8601Regex.test(dateString)) return false;

    const date = new Date(dateString);
    return !isNaN(date.getTime());
}

console.log(isValidISO8601("2024-04-15T14:30:00Z"));  // true
console.log(isValidISO8601("2024-04-15 14:30:00"));   // false

Erros comuns da ISO 8601 a serem evitados

1. Falta o separador T

// ❌ Wrong
"2024-04-15 14:30:00Z"

// ✅ Correct
"2024-04-15T14:30:00Z"

2. Formato de fuso horário errado

# ❌ Wrong - Missing colon in offset
"2024-04-15T14:30:00+0530"

# ✅ Correct - Colon in offset
"2024-04-15T14:30:00+05:30"

3. Misturando formatos de data

// ❌ Wrong - US format
"04/15/2024T14:30:00Z"

// ✅ Correct - ISO 8601
"2024-04-15T14:30:00Z"

4. Omitindo zeros à esquerda

# ❌ Wrong
"2024-4-5T9:5:0Z"

# ✅ Correct
"2024-04-05T09:05:00Z"

ISO 8601 em diferentes linguagens de programação

###JavaScript/TypeScript

// Current time in ISO 8601
const now = new Date().toISOString();
console.log(now);  // "2024-04-15T14:30:00.123Z"

// Parse ISO 8601 string
const date = new Date("2024-04-15T14:30:00Z");

// Custom formatting (using Intl)
const formatter = new Intl.DateTimeFormat('en-US', {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    second: '2-digit',
    timeZone: 'UTC',
    hour12: false
});

###Píton

from datetime import datetime, timezone

# Current time in ISO 8601
now = datetime.now(timezone.utc).isoformat()
print(now)  # "2024-04-15T14:30:00.123456+00:00"

# Parse ISO 8601 string
dt = datetime.fromisoformat("2024-04-15T14:30:00+00:00")

# Format as ISO 8601
formatted = dt.strftime("%Y-%m-%dT%H:%M:%S%z")

###Java

import java.time.Instant;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

// Current time in ISO 8601
String now = Instant.now().toString();
System.out.println(now);  // "2024-04-15T14:30:00.123Z"

// Parse ISO 8601 string
ZonedDateTime dt = ZonedDateTime.parse("2024-04-15T14:30:00Z");

// Format as ISO 8601
String formatted = dt.format(DateTimeFormatter.ISO_INSTANT);

PHP

<?php
// Current time in ISO 8601
$now = date('c');  // "2024-04-15T14:30:00+00:00"

// Parse ISO 8601 string
$dt = new DateTime("2024-04-15T14:30:00Z");

// Format as ISO 8601
echo $dt->format(DateTime::ATOM);  // ISO 8601 format
?>

Ir

package main

import (
    "fmt"
    "time"
)

func main() {
    // Current time in ISO 8601
    now := time.Now().UTC().Format(time.RFC3339)
    fmt.Println(now)  // "2024-04-15T14:30:00Z"

    // Parse ISO 8601 string
    dt, _ := time.Parse(time.RFC3339, "2024-04-15T14:30:00Z")
    fmt.Println(dt)
}

Rubi

require 'time'

# Current time in ISO 8601
now = Time.now.utc.iso8601
puts now  # "2024-04-15T14:30:00Z"

# Parse ISO 8601 string
dt = Time.iso8601("2024-04-15T14:30:00Z")

# Format as ISO 8601
formatted = dt.strftime("%Y-%m-%dT%H:%M:%S%z")

Ferramentas para trabalhar com ISO 8601

Conversores on-line

Conversor ISO 8601 - Converta entre ISO 8601 e formatos legíveis por humanos
Unix Timestamp Converter - Converter entre carimbos de data e hora Unix e ISO 8601
Conversor de fuso horário - Converte tempos ISO 8601 entre fusos horários

Bibliotecas e Pacotes

Idioma	Biblioteca	Descrição
JavaScript	`data-fns`	Biblioteca utilitária moderna
JavaScript	`dayjs`	Alternativa leve para moment.js
Pitão	`datahora`	Biblioteca padrão integrada
Pitão	`seta`	Melhores datas e horários
Java	`java.time`	API moderna de data/hora Java
PHP	`Carbono`	API DateTime aprimorada
Vá	`tempo`	Biblioteca padrão
Rubi	`tempo`	Biblioteca padrão

Casos de uso do mundo real

1. Respostas da API

{
  "id": "123",
  "created_at": "2024-04-15T14:30:00Z",
  "updated_at": "2024-04-15T15:45:00Z",
  "scheduled_at": "2024-04-20T09:00:00Z"
}

2. Armazenamento de banco de dados

-- PostgreSQL with timezone
CREATE TABLE events (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255),
    start_time TIMESTAMPTZ NOT NULL,  -- Stores in ISO 8601 with timezone
    end_time TIMESTAMPTZ NOT NULL
);

INSERT INTO events (name, start_time, end_time)
VALUES ('Meeting', '2024-04-15T14:30:00Z', '2024-04-15T15:30:00Z');

3. Arquivos de log

[2024-04-15T14:30:00.123Z] INFO: Application started
[2024-04-15T14:30:01.456Z] DEBUG: Loading configuration
[2024-04-15T14:30:02.789Z] INFO: Server listening on port 3000

4. Arquivos de configuração

# config.yml
scheduled_tasks:
  - name: "Daily backup"
    schedule: "2024-04-15T02:00:00Z"
    interval: "P1D"  # ISO 8601 duration: 1 day

  - name: "Weekly report"
    schedule: "2024-04-15T09:00:00Z"
    interval: "P1W"  # ISO 8601 duration: 1 week

Perguntas frequentes

O que significa o "T" na ISO 8601?

O T é um separador entre os componentes de data e hora. Significa "Tempo" e é exigido pela norma ISO 8601 para evitar ambiguidades.

A ISO 8601 é igual à RFC 3339?

RFC 3339 é um perfil (subconjunto) da ISO 8601 projetado para uso na Internet. A RFC 3339 é mais rígida e sempre exige o formato estendido com separadores, enquanto a ISO 8601 permite formatos básicos e estendidos.

Por que a ISO 8601 usa a ordem AAAA-MM-DD?

Esta ordem (da maior para a menor unidade) permite a classificação natural. Quando você classifica as datas ISO 8601 em ordem alfabética, elas são classificadas automaticamente em ordem cronológica.

Posso usar espaços em vez de "T"?

Embora alguns sistemas aceitem espaços para facilitar a leitura, o padrão ISO 8601 exige o separador T. Para máxima compatibilidade, sempre use T.

Qual fuso horário devo usar para armazenar carimbos de data/hora?

Sempre armazene carimbos de data/hora em UTC (com o designador Z) em bancos de dados e APIs. Converta para a hora local somente ao exibir aos usuários.

Como lidar com o horário de verão?

Armazene todos os horários em UTC para evitar problemas de horário de verão. Ao converter para a hora local, use bibliotecas de fuso horário adequadas que lidam com o horário de verão automaticamente.

Qual é a precisão máxima para segundos fracionários?

ISO 8601 não especifica uma precisão máxima. A maioria dos sistemas suporta milissegundos (3 dígitos), microssegundos (6 dígitos) ou nanossegundos (9 dígitos).

Posso omitir os segundos se eles forem zero?

Embora alguns sistemas aceitem 2024-04-15T14:30Z, o formato estrito ISO 8601 requer segundos: 2024-04-15T14:30:00Z.

Recursos relacionados

O que é carimbo de data/hora Unix? - Aprenda sobre carimbos de data/hora Unix e época
Compreendendo os fusos horários - Domine conceitos e práticas recomendadas de fuso horário
Timestamp Format Cheatsheet - Referência rápida para todos os formatos de timestamp
Current Unix Timestamp - Obtenha o carimbo de data/hora atual em vários formatos
[Conversor de data para carimbo de data e hora](/data para carimbo de data e hora) - Converta datas em carimbos de data e hora

Conclusão

ISO 8601 é o padrão ouro para representar datas e horas em sistemas de software. Ao seguir o formato ISO 8601, você garante que seus carimbos de data/hora sejam inequívocos, classificáveis e compatíveis com sistemas em todo o mundo.

Principais conclusões:

Use AAAA-MM-DDTHH:MM:SSZ para horários UTC
Incluir informações de fuso horário (Z ou ±HH:MM)
Armazene carimbos de data e hora em UTC e exiba na hora local
Valide strings ISO 8601 antes de analisar
Use formato estendido (com separadores) para facilitar a leitura

Dominar o formato ISO 8601 é essencial para qualquer desenvolvedor que trabalhe com datas e horas. Esteja você criando APIs, armazenando dados ou analisando arquivos de log, a ISO 8601 fornece uma abordagem confiável e padronizada para representação de tempo.

Comece a usar a ISO 8601 em seus projetos hoje e elimine a ambigüidade de data/hora para sempre! 🚀