Guide

Níveis de precisão do carimbo de data / hora: segundos, milissegundos, microssegundos e nanossegundos explicados

Compreendendo a precisão do carimbo de data/hora

Precisão do carimbo de data/hora refere-se ao nível de detalhe em que um carimbo de data/hora mede o tempo. Diferentes aplicações exigem diferentes níveis de precisão, desde precisão básica de segundo nível até medições ultraprecisas de nanossegundos. Compreender esses níveis de precisão é crucial para escolher o formato certo para seu caso de uso.

Os quatro principais níveis de precisão são:

Segundos (10 dígitos) - carimbo de data/hora Unix padrão
Milisegundos (13 dígitos) - JavaScript, padrão Java
Microssegundos (16 dígitos) – Sistemas de alta precisão
Nanossegundos (19 dígitos) – Cronometragem ultraprecisa

Os quatro níveis de precisão

1. Segundos (10 dígitos)

Carimbo de data e hora Unix padrão - O formato original e mais comum.

Formato

Example: 1704067200
Represents: January 1, 2024, 00:00:00 UTC
Precision: 1 second
Digit Count: 10 digits

Características

Intervalo: 13 de dezembro de 1901 a 19 de janeiro de 2038 (assinado em 32 bits)
Intervalo: 21 de setembro de 1677 a 4 de dezembro de 292.277.026.596 (assinado de 64 bits)
Armazenamento: 4 bytes (32 bits) ou 8 bytes (64 bits) Precisão: ±0,5 segundos

Quando usar

✅ Registro de eventos (registro de usuário, horários de login)
✅ Carimbos de data e hora do banco de dados (criado_at, atualizado_at)
✅ Tempos de modificação de arquivos
✅ Agendamento de tarefas (cron jobs, processos em lote)
✅ Carimbo de data e hora geral onde a precisão de menos de um segundo não é necessária

Exemplos de código

C/C++

c
#include <time.h>
#include <stdio.h>

int main() {
    time_t timestamp = time(NULL);
    printf("Current timestamp: %ld\n", timestamp);
    // Output: 1704067200 (10 digits)
    return 0;
}

Píton

import time

timestamp = int(time.time())
print(f"Current timestamp: {timestamp}")
# Output: 1704067200 (10 digits)

PHP

<?php
$timestamp = time();
echo "Current timestamp: $timestamp\n";
// Output: 1704067200 (10 digits)
?>

SQL

-- Most databases store TIMESTAMP with second precision
SELECT UNIX_TIMESTAMP();
-- Output: 1704067200

2. Milissegundos (13 dígitos)

JavaScript/Java Standard – Adiciona três casas decimais para precisão de milissegundos.

Formato

Example: 1704067200000
Represents: January 1, 2024, 00:00:00.000 UTC
Precision: 0.001 seconds (1 millisecond)
Digit Count: 13 digits

Características

Intervalo: ±8.640.000.000.000.000 milissegundos da época
Armazenamento: 8 bytes (número inteiro de 64 bits ou duplo) Precisão: ±0,0005 segundos (0,5 milissegundos)
Resolução: 1/1.000 de segundo

Quando usar

✅ Aplicativos Web (JavaScript Date.now())
✅ Monitoramento de desempenho (tempos de resposta da API)
✅ Tempo de animação (taxas de quadros, transições)
✅ Acompanhamento de eventos (tempos de clique, interações do usuário)
✅ Sistemas de negociação (preços de ações, execução de ordens)
✅ Comunicações em tempo real (aplicativos de chat)

Exemplos de código

JavaScript

// Get current timestamp in milliseconds
const timestamp = Date.now();
console.log(timestamp);
// Output: 1704067200000 (13 digits)

// Create Date from millisecond timestamp
const date = new Date(1704067200000);
console.log(date.toISOString());
// Output: 2024-01-01T00:00:00.000Z

Java

// Get current timestamp in milliseconds
long timestamp = System.currentTimeMillis();
System.out.println(timestamp);
// Output: 1704067200000 (13 digits)

// Create Date from millisecond timestamp
Date date = new Date(1704067200000L);
System.out.println(date);

Píton

import time

# Get timestamp in milliseconds
timestamp_ms = int(time.time() * 1000)
print(f"Millisecond timestamp: {timestamp_ms}")
# Output: 1704067200000 (13 digits)

Node.js

// High-resolution time in milliseconds
const start = performance.now();
// ... some operation ...
const end = performance.now();
console.log(`Operation took ${end - start} milliseconds`);

3. Microssegundos (16 dígitos)

Sistemas de alta precisão - Seis casas decimais para precisão de microssegundos.

Formato

Example: 1704067200000000
Represents: January 1, 2024, 00:00:00.000000 UTC
Precision: 0.000001 seconds (1 microsecond)
Digit Count: 16 digits

Características

Alcance: Extremamente amplo (±292.471 anos da época)
Armazenamento: 8 bytes (número inteiro de 64 bits) Precisão: ±0,0000005 segundos (0,5 microssegundos)
Resolução: 1/1.000.000 de segundo

Quando usar

✅ Sistemas de banco de dados (PostgreSQL, MongoDB)
✅ Computação científica (simulações de física)
✅ Protocolos de rede (carimbo de data e hora do pacote)
✅ Processamento de áudio/vídeo (sincronização de quadros)
✅ Negociação de alta frequência (execução em nível de microssegundos)
✅ Sistemas distribuídos (ordenação de eventos, causalidade)

Exemplos de código

Píton

import time

# Get timestamp in microseconds
timestamp_us = int(time.time() * 1_000_000)
print(f"Microsecond timestamp: {timestamp_us}")
# Output: 1704067200000000 (16 digits)

# Using datetime
from datetime import datetime
dt = datetime.now()
timestamp_us = int(dt.timestamp() * 1_000_000)
print(f"Microsecond timestamp: {timestamp_us}")

package main

import (
    "fmt"
    "time"
)

func main() {
    // Get current timestamp in microseconds
    timestamp := time.Now().UnixMicro()
    fmt.Printf("Microsecond timestamp: %d\n", timestamp)
    // Output: 1704067200000000 (16 digits)
}

PostgreSQL

-- PostgreSQL stores timestamps with microsecond precision
SELECT EXTRACT(EPOCH FROM NOW()) * 1000000;
-- Output: 1704067200000000

-- Create timestamp with microsecond precision
SELECT to_timestamp(1704067200.123456);
-- Output: 2024-01-01 00:00:00.123456+00

C++

#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono;

    // Get microsecond timestamp
    auto now = system_clock::now();
    auto micros = duration_cast<microseconds>(
        now.time_since_epoch()
    ).count();

    std::cout << "Microsecond timestamp: " << micros << std::endl;
    // Output: 1704067200000000 (16 digits)
    return 0;
}

4. Nanossegundos (19 dígitos)

Tempo ultrapreciso - Nove casas decimais para precisão de nanossegundos.

Formato

Example: 1704067200000000000
Represents: January 1, 2024, 00:00:00.000000000 UTC
Precision: 0.000000001 seconds (1 nanosecond)
Digit Count: 19 digits

Características

Intervalo: ±292 anos a partir da época (assinado em 64 bits)
Armazenamento: 8 bytes (número inteiro de 64 bits) Precisão: ±0,0000000005 segundos (0,5 nanossegundos)
Resolução: 1/1.000.000.000 de segundo

Quando usar

✅ Perfil de desempenho (medições do ciclo da CPU)
✅ Instrumentação de hardware (osciloscópios, analisadores lógicos)
✅ Desenvolvimento de kernel (carimbos de data e hora do agendador)
✅ Sistemas em tempo real (robótica, aeroespacial)
✅ Carimbo de data/hora criptográfico (blockchain, segurança)
✅ Experimentos de física (detecção de partículas)

Exemplos de código

Vá

package main

import (
    "fmt"
    "time"
)

func main() {
    // Get current timestamp in nanoseconds
    timestamp := time.Now().UnixNano()
    fmt.Printf("Nanosecond timestamp: %d\n", timestamp)
    // Output: 1704067200000000000 (19 digits)

    // Benchmark operations
    start := time.Now()
    // ... some operation ...
    elapsed := time.Since(start).Nanoseconds()
    fmt.Printf("Operation took %d nanoseconds\n", elapsed)
}

Ferrugem

use std::time::{SystemTime, UNIX_EPOCH};

fn main() {
    // Get nanosecond timestamp
    let duration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap();

    let nanos = duration.as_nanos();
    println!("Nanosecond timestamp: {}", nanos);
    // Output: 1704067200000000000 (19 digits)
}

C++

#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono;

    // Get nanosecond timestamp
    auto now = system_clock::now();
    auto nanos = duration_cast<nanoseconds>(
        now.time_since_epoch()
    ).count();

    std::cout << "Nanosecond timestamp: " << nanos << std::endl;
    // Output: 1704067200000000000 (19 digits)
    return 0;
}

Linux (C)

c
#include <time.h>
#include <stdio.h>

int main() {
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);

    long long nanos = (long long)ts.tv_sec * 1000000000LL + ts.tv_nsec;
    printf("Nanosecond timestamp: %lld\n", nanos);
    // Output: 1704067200000000000 (19 digits)
    return 0;
}

Tabela de comparação de precisão

Nível	Precisão	Dígitos	Exemplo	Casos de uso	Linguagens/Sistemas
Segundo	1s	10	`1704067200`	Logs, bancos de dados, agendamento	C, PHP, Python, SQL
Milissegundos	1ms (10⁻³s)	13	`1704067200000`	Aplicativos Web, negociação, APIs	Javascript, Java
Microssegundo	1μs (10⁻⁶s)	16	`1704067200000000`	HFT, áudio/vídeo, redes	Python, Go, PostgreSQL
Nanossegundos	1s (10⁻⁹s)	19	`1704067200000000000`	Perfil, hardware, criptografia	Vá, Ferrugem, C++

Convertendo entre níveis de precisão

Aumentando a escala (adicionando precisão)

// Second to Millisecond
const seconds = 1704067200;
const milliseconds = seconds * 1000;
// 1704067200000

// Millisecond to Microsecond
const microseconds = milliseconds * 1000;
// 1704067200000000

// Microsecond to Nanosecond
const nanoseconds = microseconds * 1000;
// 1704067200000000000

Reduzindo (Reduzindo a Precisão)

// Nanosecond to Microsecond
const nanos = 1704067200123456789;
const micros = Math.floor(nanos / 1000);
// 1704067200123456

// Microsecond to Millisecond
const millis = Math.floor(micros / 1000);
// 1704067200123

// Millisecond to Second
const secs = Math.floor(millis / 1000);
// 1704067200

Utilitário de conversão Python

class TimestampConverter:
    """Convert between different timestamp precision levels"""

    @staticmethod
    def to_milliseconds(timestamp, from_precision='seconds'):
        """Convert any precision to milliseconds"""
        multipliers = {
            'seconds': 1000,
            'milliseconds': 1,
            'microseconds': 0.001,
            'nanoseconds': 0.000001
        }
        return int(timestamp * multipliers[from_precision])

    @staticmethod
    def to_microseconds(timestamp, from_precision='seconds'):
        """Convert any precision to microseconds"""
        multipliers = {
            'seconds': 1_000_000,
            'milliseconds': 1000,
            'microseconds': 1,
            'nanoseconds': 0.001
        }
        return int(timestamp * multipliers[from_precision])

    @staticmethod
    def to_nanoseconds(timestamp, from_precision='seconds'):
        """Convert any precision to nanoseconds"""
        multipliers = {
            'seconds': 1_000_000_000,
            'milliseconds': 1_000_000,
            'microseconds': 1000,
            'nanoseconds': 1
        }
        return int(timestamp * multipliers[from_precision])

# Usage
converter = TimestampConverter()

# Convert 1704067200 seconds to milliseconds
ms = converter.to_milliseconds(1704067200, 'seconds')
print(ms)  # 1704067200000

Considerações de desempenho

Requisitos de armazenamento

Precisão	32 bits	64 bits	Armazenamento de banco de dados
Segundos	4 bytes	8 bytes	TIMESTAMP (4-8 bytes)
Milissegundos	❌ Estouro	8 bytes	BIGINT (8 bytes)
Microssegundos	❌ Estouro	8 bytes	BIGINT (8 bytes)
Nanossegundos	❌ Estouro	8 bytes	BIGINT (8 bytes)

Velocidade de processamento

// Benchmark: Different precision levels
const iterations = 1000000;

// Seconds (fastest)
console.time('Seconds');
for (let i = 0; i < iterations; i++) {
    const ts = Math.floor(Date.now() / 1000);
}
console.timeEnd('Seconds');
// ~10ms

// Milliseconds (fast)
console.time('Milliseconds');
for (let i = 0; i < iterations; i++) {
    const ts = Date.now();
}
console.timeEnd('Milliseconds');
// ~12ms

// Microseconds (slower)
console.time('Microseconds');
for (let i = 0; i < iterations; i++) {
    const ts = performance.now() * 1000;
}
console.timeEnd('Microseconds');
// ~25ms

Impacto na memória

import sys

# Storage comparison
second_ts = 1704067200
millisecond_ts = 1704067200000
microsecond_ts = 1704067200000000
nanosecond_ts = 1704067200000000000

print(f"Second: {sys.getsizeof(second_ts)} bytes")      # 28 bytes
print(f"Millisecond: {sys.getsizeof(millisecond_ts)} bytes") # 28 bytes
print(f"Microsecond: {sys.getsizeof(microsecond_ts)} bytes") # 28 bytes
print(f"Nanosecond: {sys.getsizeof(nanosecond_ts)} bytes")  # 32 bytes

# In arrays/databases, smaller integers = better performance

Precisão vs. Precisão

Compreendendo a diferença

Precisão: com que precisão você pode medir (o número de dígitos)
Precisão: quão próxima sua medição está do valor real

Example:
Precision: Nanosecond timestamp (19 digits)
Accuracy: System clock may only be accurate to ±50ms

Result: High precision, low accuracy

Limitações do relógio do sistema

Sistema	Resolução típica	Precisão
Janelas	15,6ms	±10-50ms
Linux	1μs - 1ms	±1-10ms
macOS	1μs	±1-10ms
SO em tempo real	1ns - 1μs	±1μs

Testando a resolução do seu sistema

import time

def measure_clock_resolution():
    """Measure actual system clock resolution"""
    samples = []
    prev = time.time()

    for _ in range(100000):
        current = time.time()
        if current != prev:
            samples.append(current - prev)
            prev = current

    if samples:
        min_diff = min(samples)
        print(f"Minimum time difference: {min_diff * 1000:.6f}ms")
        print(f"Approximate resolution: {min_diff * 1_000_000:.2f}μs")

measure_clock_resolution()

Melhores práticas

1. Escolha a precisão apropriada

# ✅ GOOD: Match precision to use case
user_login_time = int(time.time())  # Seconds are enough

# ❌ BAD: Unnecessary precision
user_login_time = int(time.time() * 1_000_000_000)  # Overkill!

2. Armazene de forma consistente

-- ✅ GOOD: Consistent precision across table
CREATE TABLE events (
    id BIGINT PRIMARY KEY,
    created_at BIGINT,      -- All in milliseconds
    updated_at BIGINT       -- All in milliseconds
);

-- ❌ BAD: Mixed precision
CREATE TABLE events (
    id BIGINT PRIMARY KEY,
    created_at INT,         -- Seconds
    updated_at BIGINT       -- Milliseconds (inconsistent!)
);

3. Documente sua escolha

/**
 * Timestamp precision: Milliseconds (13 digits)
 * Format: Unix timestamp * 1000
 * Example: 1704067200000 = Jan 1, 2024 00:00:00.000 UTC
 */
const timestamp = Date.now();

4. Lide com a conversão com cuidado

# ✅ GOOD: Explicit conversion
def seconds_to_milliseconds(seconds):
    """Convert seconds to milliseconds"""
    return int(seconds * 1000)

# ❌ BAD: Implicit/unclear
def convert(ts):
    return ts * 1000  # What precision is this?

5. Validar a precisão

function validateTimestamp(timestamp, expectedPrecision) {
    const digitCount = timestamp.toString().length;

    const expectedDigits = {
        'seconds': 10,
        'milliseconds': 13,
        'microseconds': 16,
        'nanoseconds': 19
    };

    if (digitCount !== expectedDigits[expectedPrecision]) {
        throw new Error(
            `Invalid ${expectedPrecision} timestamp: expected ${expectedDigits[expectedPrecision]} digits, got ${digitCount}`
        );
    }

    return true;
}

// Usage
validateTimestamp(1704067200000, 'milliseconds');  // ✅ Pass
validateTimestamp(1704067200, 'milliseconds');     // ❌ Error

Armadilhas Comuns

1. Perda de precisão em ponto flutuante

// ❌ BAD: JavaScript Number precision limit
const nanos = 1704067200123456789;  // 19 digits
console.log(nanos);
// Output: 1704067200123456800 (last digits lost!)

// ✅ GOOD: Use BigInt for nanoseconds
const nanos = 1704067200123456789n;
console.log(nanos.toString());
// Output: 1704067200123456789 (exact)

2. Confusão de fuso horário

# ❌ BAD: Local time affects precision
import datetime
local_time = datetime.datetime.now()  # Includes local timezone
timestamp = local_time.timestamp()

# ✅ GOOD: Always use UTC
utc_time = datetime.datetime.utcnow()
timestamp = utc_time.timestamp()

3. Problemas de estouro

c
// ❌ BAD: 32-bit overflow with milliseconds
int32_t timestamp_ms = time(NULL) * 1000;  // Overflow!

// ✅ GOOD: Use 64-bit for higher precision
int64_t timestamp_ms = (int64_t)time(NULL) * 1000;

Ferramentas relacionadas

Use nossas ferramentas gratuitas para trabalhar com diferentes precisões de carimbo de data/hora:

Unix Timestamp Converter - Converter entre níveis de precisão
Conversor de carimbo de data e hora em lote - Converta vários carimbos de data e hora
Timestamp Format Builder - Crie formatos personalizados
Current Timestamp - Obtenha carimbos de data e hora em todas as precisões

Conclusão

Compreender os níveis de precisão do carimbo de data/hora é essencial para o desenvolvimento de software moderno. Escolha o nível de precisão correto com base em seus requisitos específicos:

Segundos: carimbo de data/hora de uso geral, logs, bancos de dados
Milisegundos: aplicativos Web, APIs, recursos em tempo real
Microssegundos: negociação de alta frequência, computação científica
Nanossegundos: perfil de desempenho, instrumentação de hardware

Lembre-se:

Maior precisão = Mais armazenamento + Mais processamento
Combine a precisão com a precisão real do sistema
Seja consistente em toda a sua aplicação
Documente sua escolha para futuros desenvolvedores

Última atualização: janeiro de 2025