MakeTimestamp logo
MakeTimestamp

Guide

O que é carimbo de data/hora Unix? Guia completo para a época

O que é carimbo de data/hora Unix?

Um carimbo de data e hora Unix (também conhecido como horário Unix, horário POSIX ou horário de época) é um sistema para rastrear o tempo como um único número. Representa o número de segundos decorridos desde 00:00:00 UTC em 1º de janeiro de 1970, excluindo segundos bissextos. Este momento é chamado de época Unix.

Por exemplo, o carimbo de data/hora Unix 1704067200 representa 1º de janeiro de 2024, 00:00:00 UTC.

Principais características

  • Simples: apenas um número para representar qualquer momento
  • Universal: funciona da mesma forma em todos os fusos horários e sistemas
  • Eficiente: Fácil de armazenar, comparar e calcular com
  • Padronizado: Amplamente adotado em linguagens de programação e bancos de dados

Por que o carimbo de data/hora do Unix começa em 1º de janeiro de 1970?

O carimbo de data/hora Unix começa em 1º de janeiro de 1970, porque foi nessa época que o sistema operacional Unix estava sendo desenvolvido. Os desenvolvedores precisavam de um ponto de referência para seu sistema de tempo e escolheram uma data recente e redonda que fosse fácil de lembrar.

Esta data é conhecida como época Unix ou época. Todos os carimbos de data/hora Unix são calculados como o número de segundos desde este momento.

Contexto Histórico

  • 1969-1970: Desenvolvimento do sistema operacional Unix no Bell Labs
  • Necessidade de simplicidade: os desenvolvedores queriam uma maneira simples de controlar o tempo
  • Sistemas de 32 bits: Originalmente projetados para funcionar com números inteiros de 32 bits
  • Ampla adoção: tornou-se o padrão para cronometragem computadorizada

Como funciona o carimbo de data/hora Unix

Conceito Básico

O carimbo de data/hora Unix é simplesmente um contador que aumenta 1 a cada segundo:

Unix Epoch (Start):  0          → January 1, 1970, 00:00:00 UTC
After 1 second:      1          → January 1, 1970, 00:00:01 UTC
After 1 hour:        3600       → January 1, 1970, 01:00:00 UTC
After 1 day:         86400      → January 2, 1970, 00:00:00 UTC
After 1 year:        31536000   → January 1, 1971, 00:00:00 UTC
Today (2025):        ~1735689600 → Current time

Níveis de precisão

Os carimbos de data/hora Unix podem ter diferentes níveis de precisão:

PrecisãoDígitosExemploDescrição
Segundos101704067200Carimbo de data/hora Unix padrão
Milissegundos131704067200000Usado em JavaScript, Java
Microssegundos161704067200000000Sistemas de alta precisão
Nanossegundos191704067200000000000Cronometragem ultraprecisa

Timestamp Unix em diferentes linguagens de programação

###JavaScript/Node.js

// Get current Unix timestamp (milliseconds)
const timestamp = Date.now();
console.log(timestamp); // 1704067200000

// Get Unix timestamp in seconds
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // 1704067200

// Convert Unix timestamp to Date
const date = new Date(1704067200000);
console.log(date); // 2024-01-01T00:00:00.000Z

// Convert Date to Unix timestamp
const timestamp2 = new Date('2024-01-01').getTime();
console.log(timestamp2); // 1704067200000

###Píton

import time
from datetime import datetime

# Get current Unix timestamp
timestamp = time.time()
print(timestamp)  # 1704067200.123456

# Get Unix timestamp (integer)
timestamp_int = int(time.time())
print(timestamp_int)  # 1704067200

# Convert Unix timestamp to datetime
dt = datetime.fromtimestamp(1704067200)
print(dt)  # 2024-01-01 00:00:00

# Convert datetime to Unix timestamp
timestamp2 = datetime(2024, 1, 1).timestamp()
print(timestamp2)  # 1704067200.0

PHP

<?php
// Get current Unix timestamp
$timestamp = time();
echo $timestamp; // 1704067200

// Convert Unix timestamp to date
$date = date('Y-m-d H:i:s', 1704067200);
echo $date; // 2024-01-01 00:00:00

// Convert date to Unix timestamp
$timestamp2 = strtotime('2024-01-01');
echo $timestamp2; // 1704067200
?>

###Java

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;

// Get current Unix timestamp (seconds)
long timestamp = Instant.now().getEpochSecond();
System.out.println(timestamp); // 1704067200

// Get Unix timestamp (milliseconds)
long timestampMillis = System.currentTimeMillis();
System.out.println(timestampMillis); // 1704067200000

// Convert Unix timestamp to LocalDateTime
LocalDateTime dateTime = LocalDateTime.ofEpochSecond(
    1704067200, 0, ZoneOffset.UTC
);
System.out.println(dateTime); // 2024-01-01T00:00:00

// Convert LocalDateTime to Unix timestamp
long timestamp2 = dateTime.toEpochSecond(ZoneOffset.UTC);
System.out.println(timestamp2); // 1704067200

Ir

package main

import (
    "fmt"
    "time"
)

func main() {
    // Get current Unix timestamp
    timestamp := time.Now().Unix()
    fmt.Println(timestamp) // 1704067200

    // Convert Unix timestamp to Time
    t := time.Unix(1704067200, 0)
    fmt.Println(t) // 2024-01-01 00:00:00 +0000 UTC

    // Convert Time to Unix timestamp
    timestamp2 := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).Unix()
    fmt.Println(timestamp2) // 1704067200
}

Vantagens do carimbo de data/hora Unix

1. Simplicidade

É mais fácil trabalhar com um único número do que com sequências complexas de data/hora.

2. Independência de fuso horário

Os carimbos de data/hora Unix estão sempre em UTC, eliminando confusão de fuso horário.

3. Cálculos fáceis

Calcule as diferenças de tempo por subtração simples:

const start = 1704067200; // Jan 1, 2024
const end = 1704153600;   // Jan 2, 2024
const difference = end - start; // 86400 seconds = 1 day

4. Armazenamento eficiente

Armazenar um único número inteiro é mais eficiente do que armazenar strings de data.

5. Classificação e comparação

Fácil de classificar e comparar carimbos de data/hora:

const timestamps = [1704153600, 1704067200, 1704240000];
timestamps.sort((a, b) => a - b); // Chronological order

Limitações do carimbo de data/hora Unix

1. Problema do ano 2038

Em sistemas de 32 bits, os carimbos de data/hora Unix transbordarão em 19 de janeiro de 2038, 03:14:07 UTC. Isso ocorre porque inteiros assinados de 32 bits só podem representar valores até 2.147.483.647.

Solução: use carimbos de data/hora de 64 bits, que podem representar datas no futuro distante.

2. Segundos bissextos

Os carimbos de data e hora Unix ignoram os segundos bissextos, que ocasionalmente são adicionados ao UTC para explicar a rotação irregular da Terra.

3. Limitações de precisão

Os carimbos de data/hora Unix padrão (segundos) podem não ser precisos o suficiente para alguns aplicativos. Use milissegundos ou microssegundos para maior precisão.

4. Legibilidade Humana

Os carimbos de data/hora Unix não são legíveis por humanos. Você precisa convertê-los para exibir datas significativas.

Casos de uso comuns

1. Carimbos de data e hora do banco de dados

Armazene tempos de criação e modificação de forma eficiente:

CREATE TABLE users (
    id INT PRIMARY KEY,
    username VARCHAR(50),
    created_at BIGINT,
    updated_at BIGINT
);

2. Respostas da API

Incluir carimbos de data/hora nas respostas da API:

{
  "id": 123,
  "message": "Hello World",
  "timestamp": 1704067200,
  "created_at": 1704067200
}

3. Arquivos de log

Acompanhe quando os eventos ocorrem:

[1704067200] INFO: User logged in
[1704067205] WARNING: Failed login attempt
[1704067210] ERROR: Database connection failed

4. Cache e Expiração

Defina os tempos de expiração do cache:

const cacheExpiry = Date.now() / 1000 + 3600; // Expire in 1 hour

5. Gerenciamento de sessão

Rastreie os carimbos de data/hora da sessão do usuário:

const sessionStart = Math.floor(Date.now() / 1000);
const sessionExpiry = sessionStart + 1800; // 30 minutes

Melhores práticas

1. Sempre use UTC

Armazene carimbos de data/hora Unix em UTC para evitar problemas de fuso horário.

2. Escolha a precisão apropriada

  • Use segundos para a maioria dos aplicativos
  • Use milissegundos para aplicações web (JavaScript)
  • Use microssegundos ou nanossegundos para cronometragem de alta precisão

3. Use números inteiros de 64 bits

Evite o problema do ano 2038 usando carimbos de data/hora de 64 bits.

4. Validar carimbos de data e hora

Verifique se os carimbos de data/hora estão dentro de intervalos razoáveis:

function isValidTimestamp(timestamp) {
    const min = 0; // Unix epoch
    const max = 2147483647; // Year 2038 for 32-bit
    return timestamp >= min && timestamp <= max;
}

5. Precisão do documento

Sempre documente se seus carimbos de data/hora estão em segundos, milissegundos ou outras unidades.

Convertendo carimbos de data/hora Unix

Ferramentas on-line

Use MakeTimestamp.com para converter carimbos de data/hora Unix em datas legíveis por humanos e vice-versa.

Linha de comando

Linux/Mac:

# Current Unix timestamp
date +%s

# Convert Unix timestamp to date
date -d @1704067200

# Convert date to Unix timestamp
date -d "2024-01-01" +%s

Windows PowerShell:

powershell
# Current Unix timestamp
[int][double]::Parse((Get-Date -UFormat %s))

# Convert Unix timestamp to date
[DateTimeOffset]::FromUnixTimeSeconds(1704067200).DateTime

Conceitos Relacionados

ISO 8601

Um formato padronizado de data/hora: 2024-01-01T00:00:00Z

RFC 3339

Formato de carimbo de data/hora da Internet: 2024-01-01T00:00:00+00:00

Hora POSIX

Outro nome para o horário Unix, definido pelo padrão POSIX.

Época

Termo geral para o tempo medido a partir de um ponto de partida específico (época).

Perguntas frequentes

O que representa o timestamp 0 do Unix?

O carimbo de data/hora Unix 0 representa a época Unix: 1º de janeiro de 1970, 00:00:00 UTC.

Os carimbos de data/hora do Unix podem ser negativos?

Sim! Os carimbos de data/hora Unix negativos representam datas anteriores a 1º de janeiro de 1970. Por exemplo, -86400 representa 31 de dezembro de 1969.

Por que alguns carimbos de data/hora têm 13 dígitos?

Os carimbos de data/hora de 13 dígitos estão em milissegundos (comumente usados ​​em JavaScript), enquanto os carimbos de data/hora de 10 dígitos estão em segundos.

Como faço para converter entre segundos e milissegundos?

  • Segundos em milissegundos: Multiplique por 1000
  • Milissegundos em segundos: Divida por 1000

O que acontece depois do ano de 2038?

Em sistemas de 64 bits, os carimbos de data/hora Unix podem representar datas até o ano 292.277.026.596. Em sistemas de 32 bits, você precisará atualizar ou usar representações de hora alternativas.

Os carimbos de data/hora do Unix são afetados pelos fusos horários?

Não! Os carimbos de data/hora Unix estão sempre em UTC. Os fusos horários são aplicados apenas ao exibir o carimbo de data/hora como uma data legível por humanos.

Resumo

O carimbo de data/hora Unix é uma maneira simples, eficiente e universal de representar o tempo como um único número. Ele conta os segundos desde 1º de janeiro de 1970 (época Unix) e é amplamente utilizado em programação, bancos de dados e APIs.

Principais conclusões:

  • Carimbo de data e hora Unix = segundos desde 1º de janeiro de 1970, 00:00:00 UTC
  • Simples, universal e eficiente para controle de tempo
  • Disponível em vários níveis de precisão (segundos, milissegundos, etc.)
  • Cuidado com o problema do ano 2038 em sistemas de 32 bits
  • Sempre armazene carimbos de data/hora em UTC

Pronto para trabalhar com carimbos de data/hora Unix? Experimente nosso Unix Timestamp Converter para converter instantaneamente entre carimbos de data e hora e datas legíveis por humanos!