Recursos de timestamp

Cheatsheet do formato Timestamp: Guia de referência rápida

Visão geral

Esta planilha abrangente fornece referência rápida para todos os formatos de carimbo de data/hora comuns usados em programação e troca de dados. Todos os exemplos usam 1º de janeiro de 2024, 12:00:00 UTC como horário de referência.

Tabela de referência rápida

Formato	Exemplo	Comprimento	Caso de uso
Segundos Unix	`1704110400`	10 dígitos	Sistemas legados, APIs
Milissegundos Unix	`1704110400000`	13 dígitos	JavaScript, Java, APIs modernas
Microssegundos Unix	`1704110400000000`	16 dígitos	Registro de alta precisão
Nanossegundos Unix	`1704110400000000000`	19 dígitos	Monitoramento de desempenho
ISO 8601 (UTC)	`2024-01-01T12:00:00Z`	Variável	Padrão internacional
ISO 8601 (fuso horário)	`2024-01-01T12:00:00+00:00`	Variável	Dados com reconhecimento de fuso horário
RFC 3339	`2024-01-01T12:00:00.000Z`	Variável	Carimbos de data e hora da Internet
RFC 2822	`Seg, 01 de janeiro de 2024 12:00:00 +0000`	Variável	Cabeçalhos de e-mail
SQL DATA HORA	`2024-01-01 12:00:00`	19 caracteres	Armazenamento de banco de dados

Formatos de carimbo de data/hora Unix

Segundos (10 dígitos)

Formato: número inteiro representando segundos desde 1º de janeiro de 1970, 00:00:00 UTC

1704110400

Quando usar:

Sistemas legados e APIs
Eficiência de armazenamento (4 bytes como int32)
Considerações sobre o problema do ano 2038

Exemplos de código:

// JavaScript
const timestamp = Math.floor(Date.now() / 1000);
// 1704110400

const date = new Date(timestamp * 1000);
// 2024-01-01T12:00:00.000Z

# Python
import time
timestamp = int(time.time())
# 1704110400

from datetime import datetime
date = datetime.fromtimestamp(timestamp)
# 2024-01-01 12:00:00

// PHP
$timestamp = time();
// 1704110400

$date = date('Y-m-d H:i:s', $timestamp);
// 2024-01-01 12:00:00

// Go
import "time"

timestamp := time.Now().Unix()
// 1704110400

date := time.Unix(timestamp, 0)
// 2024-01-01 12:00:00 +0000 UTC

Milissegundos (13 dígitos)

Formato: número inteiro representando milissegundos desde a época Unix

1704110400000

Quando usar:

Aplicativos JavaScript (padrão para Date.now())
APIs web modernas
Precisão de milissegundos necessária

Exemplos de código:

// JavaScript
const timestamp = Date.now();
// 1704110400000

const date = new Date(timestamp);
// 2024-01-01T12:00:00.000Z

# Python
import time
timestamp = int(time.time() * 1000)
# 1704110400000

from datetime import datetime
date = datetime.fromtimestamp(timestamp / 1000)

// Java
long timestamp = System.currentTimeMillis();
// 1704110400000

Date date = new Date(timestamp);
// Mon Jan 01 12:00:00 UTC 2024

// C#
long timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
// 1704110400000

DateTimeOffset date = DateTimeOffset.FromUnixTimeMilliseconds(timestamp);

Microssegundos (16 dígitos)

Formato: número inteiro representando microssegundos desde a época Unix

1704110400000000

Quando usar:

Registro e monitoramento de alta precisão
Benchmarking de desempenho
Aplicações científicas

Exemplos de código:

# Python
import time
timestamp = int(time.time() * 1_000_000)
# 1704110400000000

date = datetime.fromtimestamp(timestamp / 1_000_000)

// Go
timestamp := time.Now().UnixMicro()
// 1704110400000000

date := time.UnixMicro(timestamp)

// Rust
use std::time::{SystemTime, UNIX_EPOCH};

let timestamp = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .unwrap()
    .as_micros();
// 1704110400000000

Nanossegundos (19 dígitos)

Formato: número inteiro representando nanossegundos desde a época Unix

1704110400000000000

Quando usar:

Requisitos de tempo ultraprecisos
Perfil de desempenho
Sistemas de negociação

Exemplos de código:

// Go
timestamp := time.Now().UnixNano()
// 1704110400000000000

date := time.Unix(0, timestamp)

// Rust
let timestamp = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .unwrap()
    .as_nanos();
// 1704110400000000000

Formatos ISO 8601

Formato Básico (UTC)

Formato: `AAAA-MM-DDTHH:MM:SSZ

2024-01-01T12:00:00Z
```
**Quando usar:**
- Troca internacional de dados
-API RESTful
- Armazenamento de dados JSON

**Exemplos de código:**
```javascript
// JavaScript
const isoString = new Date().toISOString();
// 2024-01-01T12:00:00.000Z
```

```python
# Python
from datetime import datetime, timezone
iso_string = datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')
# 2024-01-01T12:00:00Z
```

```php
// PHP
$iso_string = gmdate('Y-m-d\TH:i:s\Z');
// 2024-01-01T12:00:00Z
```
### Formato estendido (com milissegundos)

**Formato**: `AAAA-MM-DDTHH:MM:SS.sssZ

2024-01-01T12:00:00.000Z


```javascript
// JavaScript (default)
new Date().toISOString();
// 2024-01-01T12:00:00.000Z

# Python
datetime.now(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00', 'Z')
# 2024-01-01T12:00:00.000Z

Com deslocamento de fuso horário

Formato: `AAAA-MM-DDTHH:MM:SS±HH:MM

2024-01-01T12:00:00+00:00
2024-01-01T17:30:00+05:30  # IST
2024-01-01T07:00:00-05:00  # EST
```
**Exemplos de código:**
```javascript
// JavaScript
const date = new Date();
const offset = -date.getTimezoneOffset();
const sign = offset >= 0 ? '+' : '-';
const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, '0');
const minutes = String(Math.abs(offset) % 60).padStart(2, '0');
const iso = date.toISOString().replace('Z', `${sign}${hours}:${minutes}`);
// 2024-01-01T12:00:00.000+00:00
```

```python
# Python
datetime.now(timezone.utc).isoformat()
# 2024-01-01T12:00:00+00:00

# With specific timezone
from datetime import timezone, timedelta
ist = timezone(timedelta(hours=5, minutes=30))
datetime.now(ist).isoformat()
# 2024-01-01T17:30:00+05:30
```
### Somente data

**Formato**: `AAAA-MM-DD

2024-01-01


```javascript
// JavaScript
new Date().toISOString().split('T')[0];
// 2024-01-01

# Python
datetime.now().date().isoformat()
# 2024-01-01

Somente tempo

Formato: HH:MM:SS ou `HH:MM:SS.sss

12:00:00
12:00:00.000
```

```javascript
// JavaScript
new Date().toISOString().split('T')[1];
// 12:00:00.000Z
```

```python
# Python
datetime.now().time().isoformat()
# 12:00:00.000000
```
---

## Formato RFC 3339

**Formato**: `AAAA-MM-DDTHH:MM:SS.sss±HH:MM` ou `...Z

2024-01-01T12:00:00.000Z 2024-01-01T12:00:00.000+00:00

**Diferença da ISO 8601:**
- Sempre inclui milissegundos
- Sempre inclui fuso horário
- Especificação mais rigorosa

**Exemplos de código:**
```javascript
// JavaScript
new Date().toISOString(); // Already RFC 3339 compliant
// 2024-01-01T12:00:00.000Z

# Python
from datetime import datetime, timezone
datetime.now(timezone.utc).isoformat()
# 2024-01-01T12:00:00.000000+00:00

// Go
time.Now().UTC().Format(time.RFC3339Nano)
// 2024-01-01T12:00:00.000000000Z

Formato RFC 2822

Formato: `Dia, DD Seg AAAA HH:MM:SS ±HHMM

Mon, 01 Jan 2024 12:00:00 +0000
Mon, 01 Jan 2024 12:00:00 GMT
```
**Quando usar:**
- Cabeçalhos de e-mail (campo Data)
- Cabeçalhos HTTP
- feeds RSS

**Exemplos de código:**
```javascript
// JavaScript
new Date().toUTCString();
// Mon, 01 Jan 2024 12:00:00 GMT
```

```python
# Python
from email.utils import formatdate
formatdate(timeval=None, localtime=False, usegmt=True)
# Mon, 01 Jan 2024 12:00:00 GMT
```

```php
// PHP
date('r');
// Mon, 01 Jan 2024 12:00:00 +0000
```
---

## Formatos de carimbo de data/hora SQL

### MySQL/MariaDB DATETIME

**Formato**: `AAAA-MM-DD HH:MM:SS

2024-01-01 12:00:00


```sql
-- MySQL
SELECT NOW();
-- 2024-01-01 12:00:00

SELECT DATE_FORMAT(NOW(), '%Y-%m-%d %H:%i:%s');
-- 2024-01-01 12:00:00

PostgreSQL TIMESTAMP

Formato: `AAAA-MM-DD HH:MM:SS.ssssss±TZ

2024-01-01 12:00:00.000000+00
2024-01-01 12:00:00+00
```

```sql
-- PostgreSQL
SELECT NOW();
-- 2024-01-01 12:00:00.000000+00

SELECT CURRENT_TIMESTAMP;
-- 2024-01-01 12:00:00.000000+00
```
### SQLite DATETIME

**Formato**: `AAAA-MM-DD HH:MM:SS` (armazenado como texto)
```
2024-01-01 12:00:00
```

```sql
-- SQLite
SELECT datetime('now');
-- 2024-01-01 12:00:00

SELECT strftime('%Y-%m-%d %H:%M:%S', 'now');
-- 2024-01-01 12:00:00
```
###Microsoft SQL Server

**Formato**: `AAAA-MM-DD HH:MM:SS.sss

2024-01-01 12:00:00.000


```sql
-- SQL Server
SELECT GETUTCDATE();
-- 2024-01-01 12:00:00.000

SELECT FORMAT(GETUTCDATE(), 'yyyy-MM-dd HH:mm:ss.fff');
-- 2024-01-01 12:00:00.000

Formatos específicos do idioma

JavaScript

// Various formats
const date = new Date();

// ISO 8601
date.toISOString();                    // 2024-01-01T12:00:00.000Z

// Locale string
date.toLocaleString();                  // 1/1/2024, 12:00:00 PM

// UTC string
date.toUTCString();                     // Mon, 01 Jan 2024 12:00:00 GMT

// Date only
date.toLocaleDateString();              // 1/1/2024

// Time only
date.toLocaleTimeString();              // 12:00:00 PM

// Custom format
date.toLocaleString('en-US', {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit',
  hour: '2-digit',
  minute: '2-digit',
  second: '2-digit',
  hour12: false
});
// 01/01/2024, 12:00:00

Códigos Python strftime

from datetime import datetime

dt = datetime(2024, 1, 1, 12, 0, 0)

# Common formats
dt.strftime('%Y-%m-%d')                 # 2024-01-01
dt.strftime('%Y-%m-%d %H:%M:%S')       # 2024-01-01 12:00:00
dt.strftime('%Y-%m-%dT%H:%M:%SZ')      # 2024-01-01T12:00:00Z
dt.strftime('%d/%m/%Y')                 # 01/01/2024
dt.strftime('%m/%d/%Y')                 # 01/01/2024
dt.strftime('%B %d, %Y')                # January 01, 2024
dt.strftime('%A, %B %d, %Y')           # Monday, January 01, 2024
dt.strftime('%I:%M %p')                 # 12:00 PM

PHP data() Formato

<?php
$timestamp = 1704110400;

// Common formats
date('Y-m-d', $timestamp);              // 2024-01-01
date('Y-m-d H:i:s', $timestamp);       // 2024-01-01 12:00:00
date('c', $timestamp);                  // 2024-01-01T12:00:00+00:00 (ISO 8601)
date('r', $timestamp);                  // Mon, 01 Jan 2024 12:00:00 +0000 (RFC 2822)
date('U', $timestamp);                  // 1704110400 (Unix timestamp)
date('d/m/Y', $timestamp);              // 01/01/2024
date('m/d/Y', $timestamp);              // 01/01/2024
date('F j, Y', $timestamp);             // January 1, 2024
date('l, F j, Y', $timestamp);         // Monday, January 1, 2024
date('g:i A', $timestamp);              // 12:00 PM

Ir formato de hora

package main

import (
    "time"
)

func main() {
    t := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)

    // Standard formats
    t.Format(time.RFC3339)              // 2024-01-01T12:00:00Z
    t.Format(time.RFC3339Nano)          // 2024-01-01T12:00:00.000000000Z
    t.Format(time.RFC822)               // 01 Jan 24 12:00 UTC
    t.Format(time.RFC1123)              // Mon, 01 Jan 2024 12:00:00 UTC

    // Custom formats (using reference time: Jan 2 15:04:05 2006 MST)
    t.Format("2006-01-02")              // 2024-01-01
    t.Format("2006-01-02 15:04:05")    // 2024-01-01 12:00:00
    t.Format("01/02/2006")              // 01/01/2024
    t.Format("January 2, 2006")         // January 1, 2024
    t.Format("3:04 PM")                 // 12:00 PM
}

Java SimpleDateFormat

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;

Date date = new Date(1704110400000L);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

// Common patterns
"yyyy-MM-dd"                            // 2024-01-01
"yyyy-MM-dd HH:mm:ss"                  // 2024-01-01 12:00:00
"yyyy-MM-dd'T'HH:mm:ss'Z'"            // 2024-01-01T12:00:00Z
"dd/MM/yyyy"                            // 01/01/2024
"MM/dd/yyyy"                            // 01/01/2024
"MMMM d, yyyy"                          // January 1, 2024
"EEEE, MMMM d, yyyy"                   // Monday, January 1, 2024
"h:mm a"                                // 12:00 PM

Referência rápida de conversão de formato

###Unix→ISO 8601

// JavaScript
new Date(1704110400000).toISOString();
// 2024-01-01T12:00:00.000Z

# Python
from datetime import datetime, timezone
datetime.fromtimestamp(1704110400, timezone.utc).isoformat()
# 2024-01-01T12:00:00+00:00

ISO 8601 → Unix

// JavaScript
new Date('2024-01-01T12:00:00Z').getTime();
// 1704110400000

# Python
from datetime import datetime
datetime.fromisoformat('2024-01-01T12:00:00+00:00').timestamp()
# 1704110400.0

RFC 2822 → ISO 8601

// JavaScript
new Date('Mon, 01 Jan 2024 12:00:00 GMT').toISOString();
// 2024-01-01T12:00:00.000Z

# Python
from email.utils import parsedate_to_datetime
parsedate_to_datetime('Mon, 01 Jan 2024 12:00:00 GMT').isoformat()
# 2024-01-01T12:00:00+00:00

Melhores práticas

Recomendações de armazenamento

Bancos de dados: Use o tipo nativo TIMESTAMP com suporte de fuso horário
APIs: use ISO 8601 com fuso horário para portabilidade
Processamento Interno: Use milissegundos Unix para cálculos
Registro: use ISO 8601 com milissegundos e fuso horário

Tratamento de fuso horário

Sempre inclua o fuso horário - Evite carimbos de data/hora ambíguos
Armazenar em UTC - Converter para a hora local apenas para exibição
Use Z para UTC - Mais claro que +00:00
Validar compensações de fuso horário - Certifique-se de que estejam entre -12h e +14h

Seleção de precisão

Precisão	Caso de uso	Exemplo
Segundos	Eventos de usuário, agendamento	`1704110400`
Milissegundos	Aplicativos da Web, registro em log geral	`1704110400000`
Microssegundos	Monitoramento de desempenho	`1704110400000000`
Nanossegundos	Negociação de alta frequência	`1704110400000000000`

Armadilhas Comuns

❌ Evite:

Armazenar carimbos de data/hora sem informações de fuso horário
Usando a hora local para armazenamento (use sempre UTC)
Misturar diferentes níveis de precisão
Compensações de fuso horário codificadas
Usando números inteiros de 32 bits (problema do ano 2038)

✅ Faça:

Sempre inclua designadores de fuso horário (Z ou ±HH:MM)
Armazene em UTC, converta para a hora local apenas para exibição
Use precisão consistente em todo o seu sistema
Use objetos datetime com reconhecimento de fuso horário
Use números inteiros de 64 bits para carimbos de data/hora Unix

Ferramentas relacionadas

Unix Timestamp Converter - Converter entre formatos
Timestamp Format Builder - Crie formatos personalizados
Conversor de fuso horário - Lidar com conversões de fuso horário
Conversor de carimbo de data e hora em lote - Converta vários carimbos de data e hora

Cheatsheet do formato Timestamp: Guia de referência rápida

Visão geral

Tabela de referência rápida

Formatos de carimbo de data/hora Unix

Segundos (10 dígitos)

Milissegundos (13 dígitos)

Microssegundos (16 dígitos)

Nanossegundos (19 dígitos)

Formatos ISO 8601

Formato Básico (UTC)

Com deslocamento de fuso horário

Somente tempo

Formato RFC 2822

PostgreSQL TIMESTAMP

Formatos específicos do idioma

JavaScript

Códigos Python strftime

PHP data() Formato

Ir formato de hora

Java SimpleDateFormat

Referência rápida de conversão de formato

ISO 8601 → Unix

RFC 2822 → ISO 8601

Melhores práticas

Recomendações de armazenamento

Tratamento de fuso horário

Seleção de precisão

Armadilhas Comuns

Ferramentas relacionadas

Guias relacionados