logo
GeekFormat

Conversor Unix Timestamp

Timestamp Unix atual
1784571538
2026-07-21 02:18:58 (UTC)

Exemplos de código

JavaScript
// Obter timestamp atual new Date(Converter timestamp para data).toLocaleString()
Python
import time time.time() # Obter timestamp atual time.ctime(1800000000) # Converter timestamp para data
Go
import "time" time.Now().Unix() // Obter timestamp atual time.Unix(1800000000, 0).String()
Bash
# Obter timestamp atual date +%s # Converter timestamp para data date -d @1800000000

O 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

  1. O topo da página exibe um Unix Timestamp atual em tempo real que pode ser copiado diretamente com um clique
  2. Para converter timestamp em data: Insira o timestamp na aba 'Timestamp → Data'—a ferramenta detecta automaticamente segundos/milissegundos/microssegundos
  3. Selecione o fuso horário UTC ou Local; o resultado aparece instantaneamente e pode ser copiado com o botão de cópia
  4. Para converter data em timestamp: Alterne para a aba 'Data → Timestamp' e preencha os campos ano/mês/dia/hora/minuto/segundo
  5. 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

javascript

Mé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

python

Uso 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:00

Operações de Timestamp na Linha de Comando Linux/macOS

bash

Comandos 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 TempoSegundosExemplo de Uso
1 minuto60TTL curto de cache, timeouts de API
1 hora3,600Tokens de curta duração, timeouts de sessão
1 dia86,400Estatísticas diárias, relatórios diários
1 semana604,800Relatórios semanais, expiração de cookie
1 mês (30,44 dias)2,629,743Faturamento mensal, ciclos de assinatura
1 ano (365,24 dias)31,556,926Dados anuais, JWT tokens de longa duração

Operações de Timestamp por Linguagem de Programação

LinguagemObter Atual (segundos)Timestamp para Legível
JavaScriptMath.floor(Date.now()/1000)new Date(ts*1000).toLocaleString()
Pythonimport time; int(time.time())import time; time.ctime(ts)
JavaSystem.currentTimeMillis()/1000new Date(ts*1000L).toString()
Gotime.Now().Unix()time.Unix(ts, 0).String()
PHPtime()date('Y-m-d H:i:s', ts)
MySQLSELECT UNIX_TIMESTAMP()SELECT FROM_UNIXTIME(ts)
Bash (Linux)date +%sdate -d @ts
Bash (macOS)date +%sdate -r ts

Authoritative References