MakeTimestamp logo
MakeTimestamp

Guide

Conversor de carimbo de data/hora para ISO 8601 (segundos, milis, nanos)

Por que esta página

Freqüentemente, você obtém carimbos de data/hora em segundos (10 dígitos), milissegundos (13), microssegundos (16) ou nanossegundos (19). Esta página fornece regras completas, snippets prontos para envio e CTAs para o conversor completo para que você possa transformar qualquer época em ISO 8601/RFC 3339 sem adivinhar a precisão.

Início rápido (fluxo MVP)

  1. Cole o carimbo de data/hora (detectamos automaticamente o comprimento e a precisão).
  2. Escolha o fuso horário: UTC ou deslocamento personalizado (por exemplo, UTC+08:00).
  3. Obtenha a saída ISO 8601 / RFC 3339 e copie com um clique.
  4. Precisa incorporar? Copie um trecho de idioma abaixo.

Experimente a ferramenta interativa: Timestamp → ISO Converter e Format Builder.

Regras de entrada e validação

  • Detecção de comprimento: 10=segundos, 13=ms, 16=µs, 19=ns.
  • Caracteres permitidos: somente dígitos; rejeitar espaços em branco e letras.
  • Intervalo: deve estar dentro dos limites de segurança da plataforma (verifique 32 bits versus 64 bits; consulte Perguntas frequentes).
  • Fuso horário: UTC padrão; deslocamentos personalizados como +08:00, -05:30.
  • DST: a saída usa ISO 8601 com reconhecimento de deslocamento; UTC evita surpresas de horário de verão.

Trechos de código

###JavaScript/Node.js

const detectPrecision = (raw) => {
  const len = raw.length;
  if (len === 10) return { value: Number(raw) * 1000, unit: "ms" };
  if (len === 13) return { value: Number(raw), unit: "ms" };
  if (len === 16) return { value: Number(raw) / 1000, unit: "ms" }; // µs → ms
  if (len === 19) return { value: Number(raw) / 1_000_000, unit: "ms" }; // ns → ms
  throw new Error("Invalid length");
};

const toIso = (raw, tz = "UTC") => {
  const { value } = detectPrecision(raw);
  // If you need a fixed offset, use luxon or temporal; here we show UTC
  return new Date(value).toISOString(); // RFC 3339 compliant
};

console.log(toIso("1704067200"));      // 10 digits -> seconds
console.log(toIso("1704067200000"));   // 13 digits -> milliseconds

###Píton

from datetime import datetime, timezone, timedelta

def to_iso(raw: str, offset_minutes: int = 0) -> str:
    length = len(raw)
    if length == 10:
        ts = int(raw)
    elif length == 13:
        ts = int(raw) / 1000
    elif length == 16:
        ts = int(raw) / 1_000_000
    elif length == 19:
        ts = int(raw) / 1_000_000_000
    else:
        raise ValueError("Invalid length")

    tz = timezone(timedelta(minutes=offset_minutes))
    return datetime.fromtimestamp(ts, tz=tz).isoformat()

print(to_iso("1704067200", 0))     # UTC
print(to_iso("1704067200000", 480)) # UTC+08:00

Ir

package main

import (
	"fmt"
	"time"
)

func parseEpoch(raw string) (time.Time, error) {
	switch len(raw) {
	case 10:
		sec, _ := time.ParseInt(raw, 10, 64)
		return time.Unix(sec, 0).UTC(), nil
	case 13:
		ms, _ := time.ParseInt(raw, 10, 64)
		return time.Unix(0, ms*int64(time.Millisecond)).UTC(), nil
	case 16:
		us, _ := time.ParseInt(raw, 10, 64)
		return time.Unix(0, us*int64(time.Microsecond)).UTC(), nil
	case 19:
		ns, _ := time.ParseInt(raw, 10, 64)
		return time.Unix(0, ns).UTC(), nil
	default:
		return time.Time{}, fmt.Errorf("invalid length")
	}
}

func main() {
	t, err := parseEpoch("1704067200000")
	if err != nil {
		panic(err)
	}
	fmt.Println(t.Format(time.RFC3339))
}

Armadilhas comuns

  • Precisão errada: carimbos de data/hora JS de 13 dígitos tratados como segundos = grande data futura.
  • Deslocamento ausente: a análise local sem especificar o fuso horário produz a hora local da máquina.
  • Bordas do horário de verão: se você precisar mostrar a hora local, escolha uma zona IANA real (por exemplo, América/Nova_Iorque) em vez de um deslocamento fixo.
  • Overflow: sistemas de 32 bits serão interrompidos após 2038 para carimbos de data/hora de segundo nível; prefira 64 bits.

Perguntas frequentes

  • P: Segundos versus milissegundos — como posso saber? A: Verifique o comprimento dos dígitos; se não tiver certeza, execute ambos e veja qual está em uma janela de data plausível.
  • P: A ISO 8601 exige Z? R: Z significa UTC. Qualquer deslocamento como +08:00 também é válido para ISO 8601/RFC 3339.
  • P: Posso converter em lote? R: Use Conversor de carimbo de data/hora em lote.

Ferramentas e guias relacionados