Conversor Unix Timestamp
Exemplos de código
// Obter timestamp atual
new Date(Converter timestamp para data).toLocaleString()import time
time.time() # Obter timestamp atual
time.ctime(1800000000) # Converter timestamp para dataimport "time"
time.Now().Unix() // Obter timestamp atual
time.Unix(1800000000, 0).String()# Obter timestamp atual
date +%s
# Converter timestamp para data
date -d @1800000000O timestamp Unix conta os segundos desde 1 de janeiro de 1970, 00:00:00 UTC.
Conversor online gratuito de Unix Timestamp com conversão bidirecional de segundos/milissegundos/microssegundos, detecção automática de unidade, alternador de fuso horário UTC/Local e exemplos de código multilíngues integrados. Pronto para uso instantâneo para desenvolvimento e depuração.
Sugestões Relacionadas
O que é um Unix Timestamp?
Um Unix Timestamp (também chamado Epoch Time ou POSIX Time) é uma forma de representar o tempo como um único número: a contagem de segundos decorridos desde 1º de janeiro de 1970, 00:00:00 UTC (o Unix Epoch), sem contar os segundos bissextos. No próprio Unix Epoch, o timestamp é 0.
A maior vantagem dos timestamps é a independência de fuso horário—o mesmo instante produz o mesmo timestamp em qualquer lugar da Terra, sem problemas de conversão de fuso horário. Isso os torna ideais para: tempos de criação/atualização de registros de banco de dados, rastreamento de logs em sistemas distribuídos (IDs de trace/span com timestamps), parâmetros de tempo de API, tempos de expiração de token JWT, valores de TTL de cache e tempos de modificação do sistema de arquivos.
Diferentes linguagens e sistemas usam diferentes precisões: C/Unix/Python usam segundos por padrão (10 dígitos), JavaScript/Java usam milissegundos (13 dígitos) e sistemas de alta precisão (negociação financeira, computação científica) usam microssegundos (16 dígitos) ou mesmo nanossegundos (19 dígitos). Esta ferramenta cobre as três precisões mais comuns: segundos, milissegundos e microssegundos.
Casos de uso
- Converta timestamps em arquivos de log para datas legíveis durante a depuração para localizar rapidamente os horários dos problemas
- Verifique campos de timestamp em payloads de solicitação/resposta durante a integração de API
- Converta horários comerciais em timestamps para consultas de intervalo de tempo SQL em operações de banco de dados
- Compare timestamps UTC com o horário local durante operações de servidor para solucionar problemas de implantações cross-fuso horário
- Copie trechos de código para obter timestamps em várias linguagens ao escrever scripts
- Converta datas históricas (antes de 1970) ou futuras em timestamps para testar casos de borda
Como Usar
- O topo da página exibe um Unix Timestamp atual em tempo real que pode ser copiado diretamente com um clique
- Para converter timestamp em data: Insira o timestamp na aba 'Timestamp → Data'—a ferramenta detecta automaticamente segundos/milissegundos/microssegundos
- Selecione o fuso horário UTC ou Local; o resultado aparece instantaneamente e pode ser copiado com o botão de cópia
- Para converter data em timestamp: Alterne para a aba 'Data → Timestamp' e preencha os campos ano/mês/dia/hora/minuto/segundo
- Após selecionar o fuso horário, o timestamp em segundos aparece instantaneamente—cópia com um clique para código ou consultas
Recursos
- Detecção automática de unidade: Cole qualquer timestamp e ele identifica automaticamente segundos/milissegundos/microssegundos—não é necessária seleção manual
- Três níveis de precisão: Cobertura completa de segundos (10 dígitos), milissegundos (13 dígitos) e microssegundos (16 dígitos) para todas as linguagens e sistemas
- Alternador UTC/Local: UTC para logs de servidor, Local para horário comercial—alternância com um clique para comparação
- Entrada de data campo por campo: Caixas de entrada separadas para ano/mês/dia/hora/minuto/segundo para conversão data-para-timestamp—não é necessário memorizar formato de data
- Exibição de timestamp ao vivo: Unix Timestamp atual em tempo real com data UTC mostrada no topo, cópia com um clique
- Trechos de código multilíngues: Código integrado JavaScript/Python/Go/Bash para obter e converter timestamps, cópia com um clique
- Suporte a timestamp negativo: Converta qualquer data de 1920 a 2100, cobrindo datas históricas e futuras
- Cálculo no lado do cliente: Todas as conversões rodam localmente em seu navegador—timestamps nunca são enviados a nenhum servidor
Exemplos de Código
Obter e Converter Timestamps em JavaScript
javascriptMétodos comuns para obter timestamps atuais em segundos/milissegundos em navegadores e Node.js, e convertê-los para horário local legível.
// Obter timestamp atual em segundos
const tsSec = Math.floor(Date.now() / 1000);
console.log(tsSec); // ex. 1700000000
// Obter timestamp atual em milissegundos
const tsMs = Date.now();
console.log(tsMs); // ex. 1700000000000
// Timestamp de segundos para horário local legível
const date = new Date(tsSec * 1000);
console.log(date.toLocaleString('pt-BR'));
// "14/11/2023 19:13:20"
// Timestamp de milissegundos para formato ISO
console.log(new Date(tsMs).toISOString());
// "2023-11-14T22:13:20.000Z"Manipulação de Timestamps em Python
pythonUso dos módulos padrão time e datetime do Python para obter e converter timestamps, incluindo manipulação de fuso horário.
import time
from datetime import datetime, timezone
# Obter timestamp atual em segundos
ts = int(time.time())
print(ts) # 1700000000
# Timestamp para string de horário local
print(time.ctime(ts))
# 'Tue Nov 14 19:13:20 2023'
# Timestamp para horário formatado
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)))
# '2023-11-14 19:13:20'
# Timestamp para horário UTC
print(datetime.fromtimestamp(ts, tz=timezone.utc))
# 2023-11-14 22:13:20+00:00Operações de Timestamp na Linha de Comando Linux/macOS
bashComandos shell comuns para obter timestamps atuais e convertê-los, observando diferenças entre o date GNU do Linux e o date BSD do macOS.
# Obter timestamp atual em segundos (funciona tanto no Linux quanto no macOS) date +%s # Timestamp para data (Linux GNU date) date -d @1700000000 # "Tue Nov 14 19:13:20 -03 2023" # Timestamp para data (macOS BSD date) date -r 1700000000 # Timestamp para data UTC (Linux) date -u -d @1700000000 # "Tue Nov 14 22:13:20 UTC 2023" # Saída com formato personalizado date -d @1700000000 '+%Y-%m-%d %H:%M:%S'
Perguntas frequentes
O que é um Unix Timestamp?
Um Unix Timestamp (também chamado Epoch Time ou POSIX Time) é o número de segundos decorridos desde 1º de janeiro de 1970, 00:00:00 UTC (Tempo Universal Coordenado), sem contar os segundos bissextos. Por exemplo, 1700000000 corresponde a 2023-11-14 22:13:20 UTC. É independente de fuso horário—o mesmo timestamp representa o mesmo instante em qualquer lugar da Terra—tornando-o o padrão para registro de tempo entre sistemas, rastreamento de logs, parâmetros de API e armazenamento em banco de dados.
Como distinguir timestamps de segundos, milissegundos e microssegundos?
Pela contagem de dígitos: 10 dígitos = segundos (ex., 1700000000), 13 dígitos = milissegundos (ex., 1700000000000), 16 dígitos = microssegundos (ex., 1700000000000000). Esta ferramenta detecta automaticamente a unidade com base no número de dígitos que você cola—não é necessária seleção manual. Ela também remove espaços em branco automaticamente, para que você possa colar diretamente dos logs.
Por que o timestamp nos logs está 8 horas adiantado em relação ao horário local?
Unix Timestamps são inerentemente baseados em UTC. Se seu fuso horário local for UTC+8 (ex., Horário Padrão da China), converter um timestamp UTC usando regras de fuso horário local mostrará uma diferença de 8 horas. Esta ferramenta fornece um alternador UTC/Local—use UTC ao ler logs de servidor (a maioria dos servidores usa UTC) e horário local para timestamps voltados a negócios.
Como obter e converter timestamps em JavaScript?
Obtenha o timestamp atual em segundos com `Math.floor(Date.now() / 1000)`, em milissegundos com `Date.now()`; converta para horário legível com `new Date(ts * 1000).toLocaleString()` (multiplique segundos por 1000, passe milissegundos diretamente). Trechos de código integrados para JavaScript, Python, Go e Bash são fornecidos na parte inferior da página para cópia direta.
Timestamps podem ser negativos? O que eles representam?
Sim. Timestamps negativos representam datas anteriores a 1º de janeiro de 1970. Por exemplo, -1 corresponde a 1969-12-31 23:59:59 UTC. Esta ferramenta suporta timestamps negativos e cobre datas de 1920 a 2100, suportando tanto datas históricas quanto datas futuras.
O que é o problema do ano de 2038? Isso afetará o uso?
O problema do ano de 2038 ocorre quando sistemas que usam inteiros sinalizados de 32 bits para armazenar Unix Timestamps transbordam após 19 de janeiro de 2038, 03:14:07 UTC, fazendo com que as datas voltem a valores negativos. Sistemas modernos usam inteiros de 64 bits (seguros por ~292 bilhões de anos) e JavaScript usa floats de 64 bits (seguros até o ano 285.616 com precisão de milissegundos). Como esta ferramenta roda em seu navegador usando JavaScript, ela não é afetada.
Por que usar um conversor online em vez da linha de comando?
Ferramentas de linha de comando (como o `date` do Linux) exigem memorização de flags de formato, e os parâmetros diferem entre plataformas (GNU date do Linux vs BSD date do macOS têm flags diferentes). Esta ferramenta funciona instantaneamente em seu navegador, detecta unidades automaticamente, fornece campos de entrada de data visuais (campos separados de ano/mês/dia/hora/minuto/segundo—não é necessário memorizar formato de data), alternância de fuso horário e trechos de código multilíngues integrados.
Glossário
- Unix Timestamp
- Segundos decorridos desde 1970-01-01 00:00:00 UTC, 10 dígitos, independente de fuso horário, globalmente consistente.
- Epoch Time
- Nome alternativo para Unix Timestamp, referindo-se ao tempo contado a partir do Unix Epoch (1970-01-01 UTC).
- Timestamp em Segundos
- Precisão de 10 dígitos até o segundo (ex., 1700000000), padrão em Unix/Python/C.
- Timestamp em Milissegundos
- Precisão de 13 dígitos até 1/1000 de segundo (ex., 1700000000000), padrão em JavaScript/Java.
- Timestamp em Microssegundos
- Precisão de 16 dígitos até 1/1.000.000 de segundo (ex., 1700000000000000), usado em sistemas de alta precisão.
- UTC
- Tempo Universal Coordenado, o padrão de tempo global e base para cálculos de fuso horário, aproximadamente equivalente a GMT.
- Offset de Fuso Horário
- Diferença entre o horário local e UTC, ex., Leste dos EUA é UTC-5 (horário padrão), Horário Padrão da China é UTC+8.
- ISO 8601
- Padrão internacional de formato de data/hora (ex., 2024-01-15T08:30:00+08:00), o padrão para parâmetros de API.
- Problema do Ano de 2038
- Transbordamento de timestamps de inteiros sinalizados de 32 bits após 19 de janeiro de 2038; sistemas de 64 bits e JavaScript não são afetados.
Conversões Comuns de Unidades de Tempo
| Unidade de Tempo | Segundos | Exemplo de Uso |
|---|---|---|
| 1 minuto | 60 | TTL curto de cache, timeouts de API |
| 1 hora | 3,600 | Tokens de curta duração, timeouts de sessão |
| 1 dia | 86,400 | Estatísticas diárias, relatórios diários |
| 1 semana | 604,800 | Relatórios semanais, expiração de cookie |
| 1 mês (30,44 dias) | 2,629,743 | Faturamento mensal, ciclos de assinatura |
| 1 ano (365,24 dias) | 31,556,926 | Dados anuais, JWT tokens de longa duração |
Operações de Timestamp por Linguagem de Programação
| Linguagem | Obter Atual (segundos) | Timestamp para Legível |
|---|---|---|
| JavaScript | Math.floor(Date.now()/1000) | new Date(ts*1000).toLocaleString() |
| Python | import time; int(time.time()) | import time; time.ctime(ts) |
| Java | System.currentTimeMillis()/1000 | new Date(ts*1000L).toString() |
| Go | time.Now().Unix() | time.Unix(ts, 0).String() |
| PHP | time() | date('Y-m-d H:i:s', ts) |
| MySQL | SELECT UNIX_TIMESTAMP() | SELECT FROM_UNIXTIME(ts) |
| Bash (Linux) | date +%s | date -d @ts |
| Bash (macOS) | date +%s | date -r ts |
Authoritative References
- Simulador de Daltonismo
- Conversor de cores
- Conversor de .htaccess para Nginx
- Conversor de SQL
- Parser de Cookies
- Gerador de Expressões Cron
- Validador de Expressões Cron
- Formatador de CSS
- Compressor de CSS
- CSV para Excel
- Conversor de Moedas
- Comparador de Diferenças
- Gerador de Favicon
- Formatador de XML
- Conversor Hexadecimal
- Formatador de HTML
- Compressor de HTML
- HTML para Markdown
- Markdown para HTML
- Formatar JavaScript
- Compressor de JS
- Formatador JSX
- Compressor de JSX
- Agrupamento de palavras-chave
- Gerador Lorem Ipsum
- Gerador de Tabela Markdown
- Gerador de Meta Tags
- Gerador de Senhas
- Verificador de Força de Senha
- Gerador de código QR/código de barras
- Testador de Expressões Regulares
- Gerador de Slug
- Gerador de SQL
- Formatador SQL
- Contador de Palavras
- Ferramenta de Tempo
- Formatador de TS
- Compressor de TS
- Formatador de TSX
- Compressão TSX
- Conversor Unix Timestamp
- Gerador UUID
- Formatador de YAML
- Conversor de caixa