MakeTimestamp logo
MakeTimestamp

Guide

Carimbo de data e hora inválido: diagnósticos rápidos e correções

A lista de verificação de diagnóstico rápido

  • Verifique comprimento: 10=segundos, 13=ms, 16=µs, 19=ns.
  • Verificar dígitos: somente números; remova espaços/letras.
  • Verifique intervalo: a data resultante é plausível e segura para 64 bits?
  • Verifique fuso horário: converta primeiro em UTC e depois aplique o deslocamento de destino.
  • Verifique DST edge: se estiver localizando, use uma zona IANA (America/New_York).

Precisa verificar agora? Vá para Conversor de carimbo de data/hora Unix ou Conversor de lote.

Tipos de erros comuns

  • Incompatibilidade de comprimento: 13 dígitos tratados como segundos → data futura distante.
  • Caracteres sem dígitos: espaços ocultos, vírgulas ou letras.
  • Fora do intervalo: estouro de segundos de 32 bits além de 2038; negativos não suportados em alguns sistemas.
  • Ambiguidade de fuso horário: hora local do servidor versus UTC esperado.
  • Mudanças de horário de verão: a análise da hora local durante a hora faltante causa falha.

Etapas de validação (copiar e colar)

// JavaScript: validate & normalize to milliseconds
export function normalizeEpoch(raw) {
  const trimmed = raw.trim();
  if (!/^[0-9]+$/.test(trimmed)) throw new Error("Digits only");
  const len = trimmed.length;
  if (len === 10) return Number(trimmed) * 1000;
  if (len === 13) return Number(trimmed);
  if (len === 16) return Number(trimmed) / 1000;
  if (len === 19) return Number(trimmed) / 1_000_000;
  throw new Error("Invalid length");
}

# Python: validate & to datetime (UTC)
from datetime import datetime, timezone

def parse_epoch(raw: str) -> datetime:
    if not raw.isdigit():
        raise ValueError("Digits only")
    n = len(raw)
    if n == 10:
        ts = int(raw)
    elif n == 13:
        ts = int(raw) / 1000
    elif n == 16:
        ts = int(raw) / 1_000_000
    elif n == 19:
        ts = int(raw) / 1_000_000_000
    else:
        raise ValueError("Invalid length")
    return datetime.fromtimestamp(ts, tz=timezone.utc)

-- SQL (PostgreSQL): validate timestamp length in a table
SELECT id, ts_raw,
       CASE
         WHEN ts_raw ~ '^[0-9]{10}$' THEN 'seconds'
         WHEN ts_raw ~ '^[0-9]{13}$' THEN 'milliseconds'
         WHEN ts_raw ~ '^[0-9]{16}$' THEN 'microseconds'
         WHEN ts_raw ~ '^[0-9]{19}$' THEN 'nanoseconds'
         ELSE 'invalid'
       END AS ts_precision
FROM events
WHERE ts_raw !~ '^[0-9]{10}$'
   OR ts_raw::numeric > 32503680000; -- > 3000-01-01 as a sanity bound

Corrigir modelos

  • Correção de precisão: detectar comprimento → dimensionar para milissegundos → executar novamente a análise.
  • Cortar / higienizar: remove espaços em branco e vírgulas antes da validação de regex.
  • Guarda de intervalo: limitar ou descartar valores fora da janela plausível (por exemplo, ano < 2000 ou > 2100).
  • Correção de fuso horário: analise como UTC e formate para o deslocamento/zona de destino do usuário.
  • Análise segura para horário de verão: prefira UTC; se local for necessário, use bibliotecas de zona IANA.

Perguntas frequentes

  • Qual é o padrão mais seguro? Analise como UTC e formate para o fuso horário solicitado.
  • Como posso evitar problemas de 2038? Armazene como números inteiros de 64 bits; evite armazenamento baseado em segundo de 32 bits.
  • Como limpar dados em lote? Use um pré-filtro regex + dimensionamento baseado em comprimento e, em seguida, canalize para um conversor; tente Conversor de carimbo de data/hora em lote.

Ferramentas e guias relacionados