Guide

Zeitstempel-Präzisionsstufen: Sekunden, Millisekunden, Mikrosekunden und Nanosekunden erklärt

Zeitstempelpräzision verstehen

Zeitstempelpräzision bezieht sich auf den Detaillierungsgrad, mit dem ein Zeitstempel die Zeit misst. Unterschiedliche Anwendungen erfordern unterschiedliche Präzisionsniveaus, von der grundlegenden Genauigkeit der zweiten Ebene bis hin zu ultrapräzisen Nanosekundenmessungen. Das Verständnis dieser Präzisionsstufen ist entscheidend für die Auswahl des richtigen Formats für Ihren Anwendungsfall.

Die vier Hauptgenauigkeitsstufen sind:

Sekunden (10 Ziffern) – Standard-Unix-Zeitstempel
Millisekunden (13 Ziffern) – JavaScript, Java-Standard
Mikrosekunden (16 Ziffern) – Hochpräzise Systeme
Nanosekunden (19 Ziffern) – Ultrapräzises Timing

Die vier Präzisionsstufen

1. Sekunden (10 Ziffern)

Standard-Unix-Zeitstempel – Das ursprüngliche und gebräuchlichste Format.

Format

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

Eigenschaften

Bereich: 13. Dezember 1901 bis 19. Januar 2038 (32-Bit signiert)
Bereich: 21. September 1677 bis 4. Dezember 292.277.026.596 (64-Bit-signiert)
Speicher: 4 Byte (32-Bit) oder 8 Byte (64-Bit)
Genauigkeit: ±0,5 Sekunden

Wann zu verwenden

✅ Ereignisprotokollierung (Benutzerregistrierung, Anmeldezeiten)
✅ Datenbank-Zeitstempel (erstellt_at, aktualisiert_at)
✅ Dateiänderungszeiten
✅ Aufgaben planen (Cron-Jobs, Batch-Prozesse)
✅ Allgemeine Zeitstempelung, bei der keine Genauigkeit im Subsekundenbereich erforderlich ist

Codebeispiele

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;
}

Python

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. Millisekunden (13 Ziffern)

JavaScript/Java Standard – Fügt drei Dezimalstellen für Millisekundengenauigkeit hinzu.

Format

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

Eigenschaften

Bereich: ±8.640.000.000.000.000 Millisekunden ab Epoche
Speicher: 8 Bytes (64-Bit-Ganzzahl oder Doppel)
Genauigkeit: ±0,0005 Sekunden (0,5 Millisekunden)
Auflösung: 1/1.000 Sekunde

Wann zu verwenden

✅ Webanwendungen (JavaScript Date.now())
✅ Leistungsüberwachung (API-Antwortzeiten)
✅ Animations-Timing (Bildraten, Übergänge)
✅ Ereignisverfolgung (Klickzeiten, Benutzerinteraktionen)
✅ Handelssysteme (Aktienkurse, Auftragsausführung)
✅ Echtzeitkommunikation (Chat-Anwendungen)

Codebeispiele

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);

Python

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. Mikrosekunden (16 Ziffern)

Hochpräzise Systeme – Sechs Dezimalstellen für Mikrosekundengenauigkeit.

Format

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

Eigenschaften

Reichweite: Extrem breit (±292.471 Jahre ab Epoche)
Speicher: 8 Bytes (64-Bit-Ganzzahl)
Genauigkeit: ±0,0000005 Sekunden (0,5 Mikrosekunden)
Auflösung: 1/1.000.000stel Sekunde

Wann zu verwenden

✅ Datenbanksysteme (PostgreSQL, MongoDB)
✅ Wissenschaftliches Rechnen (Physiksimulationen)
✅ Netzwerkprotokolle (Paket-Zeitstempel)
✅ Audio-/Videoverarbeitung (Frame-Synchronisation)
✅ Hochfrequenzhandel (Ausführung auf Mikrosekundenebene)
✅ Verteilte Systeme (Ereignisordnung, Kausalität)

Codebeispiele

Python

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}")

Gehen

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. Nanosekunden (19 Ziffern)

Ultrapräzises Timing – Neun Dezimalstellen für Nanosekunden-Präzision.

Format

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

Eigenschaften

Bereich: ±292 Jahre ab Epoche (64-Bit-signiert)
Speicher: 8 Bytes (64-Bit-Ganzzahl)
Genauigkeit: ±0,0000000005 Sekunden (0,5 Nanosekunden)
Auflösung: 1/1.000.000.000stel Sekunde

Wann zu verwenden

✅ Leistungsprofilierung (CPU-Zyklusmessungen)
✅ Hardware-Instrumentierung (Oszilloskope, Logikanalysatoren)
✅ Kernel-Entwicklung (Scheduler-Zeitstempel)
✅ Echtzeitsysteme (Robotik, Luft- und Raumfahrt)
✅ Kryptografischer Zeitstempel (Blockchain, Sicherheit)
✅ Physikexperimente (Partikeldetektion)

Codebeispiele

Geh

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)
}

Rost

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;
}

Präzisionsvergleichstabelle

Ebene	Präzision	Ziffern	Beispiel	Anwendungsfälle	Sprachen/Systeme
Zweiter	1s	10	`1704067200`	Protokolle, Datenbanken, Terminplanung	C, PHP, Python, SQL
Millisekunde	1ms (10⁻³s)	13	`1704067200000`	Web-Apps, Handel, APIs	JavaScript, Java
Mikrosekunde	1μs (10⁻⁶s)	16	`1704067200000000`	HFT, Audio/Video, Netzwerke	Python, Go, PostgreSQL
Nanosekunde	1ns (10⁻⁹s)	19	`1704067200000000000`	Profiling, Hardware, Krypto	Los, Rust, C++

Konvertieren zwischen Präzisionsstufen

Hochskalieren (Präzision hinzufügen)

// 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

Herunterskalieren (Reduzierung der Präzision)

// 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

Python-Konvertierungsdienstprogramm

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

Leistungsüberlegungen

Speicheranforderungen

Präzision	32-Bit	64-Bit	Datenbankspeicher
Sekunden	4 Byte	8 Byte	TIMESTAMP (4-8 Bytes)
Millisekunden	❌ Überlauf	8 Byte	BIGINT (8 Bytes)
Mikrosekunden	❌ Überlauf	8 Byte	BIGINT (8 Bytes)
Nanosekunden	❌ Überlauf	8 Byte	BIGINT (8 Bytes)

Verarbeitungsgeschwindigkeit

// 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

Auswirkungen auf das Gedächtnis

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

Genauigkeit vs. Präzision

Den Unterschied verstehen

Präzision: Wie fein Sie messen können (die Anzahl der Ziffern)
Genauigkeit: Wie nah Ihre Messung am wahren Wert liegt

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

Result: High precision, low accuracy

Einschränkungen der Systemuhr

System	Typische Auflösung	Genauigkeit
Windows	15,6 ms	±10-50ms
Linux	1μs - 1ms	±1-10ms
macOS	1μs	±1-10ms
Echtzeit-Betriebssystem	1ns - 1μs	±1μs

Testen Sie die Auflösung Ihres Systems

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()

Best Practices

1. Wählen Sie die richtige Präzision

# ✅ 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. Konsequent aufbewahren

-- ✅ 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. Dokumentieren Sie Ihre Wahl

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

4. Gehen Sie bei der Konvertierung vorsichtig vor

# ✅ 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. Präzision validieren

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

Häufige Fallstricke

1. Präzisionsverlust im Gleitkomma

// ❌ 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. Zeitzonenverwirrung

# ❌ 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. Überlaufprobleme

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;

Fazit

Für die moderne Softwareentwicklung ist es von entscheidender Bedeutung, die Genauigkeitsstufen von Zeitstempeln zu verstehen. Wählen Sie die richtige Präzisionsstufe basierend auf Ihren spezifischen Anforderungen:

Sekunden: Universelle Zeitstempelung, Protokolle, Datenbanken
Millisekunden: Webanwendungen, APIs, Echtzeitfunktionen
Mikrosekunden: Hochfrequenzhandel, wissenschaftliches Rechnen
Nanosekunden: Leistungsprofilierung, Hardwareinstrumentierung

Denken Sie daran:

Höhere Präzision = mehr Speicher + mehr Verarbeitung
Passen Sie die Präzision an die tatsächliche Systemgenauigkeit an
Seien Sie in Ihrer gesamten Anwendung konsistent
Dokumentieren Sie Ihre Wahl für zukünftige Entwickler

Letzte Aktualisierung: Januar 2025

Zeitstempel-Präzisionsstufen: Sekunden, Millisekunden, Mikrosekunden und Nanosekunden erklärt

Zeitstempelpräzision verstehen

Die vier Präzisionsstufen

1. Sekunden (10 Ziffern)

Format

Eigenschaften

Wann zu verwenden

Codebeispiele

2. Millisekunden (13 Ziffern)

Format

Eigenschaften

Wann zu verwenden

Codebeispiele

3. Mikrosekunden (16 Ziffern)

Format

Eigenschaften

Wann zu verwenden

Codebeispiele

4. Nanosekunden (19 Ziffern)

Format

Eigenschaften

Wann zu verwenden

Codebeispiele

Präzisionsvergleichstabelle

Konvertieren zwischen Präzisionsstufen

Hochskalieren (Präzision hinzufügen)

Herunterskalieren (Reduzierung der Präzision)

Python-Konvertierungsdienstprogramm

Leistungsüberlegungen

Speicheranforderungen

Verarbeitungsgeschwindigkeit

Auswirkungen auf das Gedächtnis

Genauigkeit vs. Präzision

Den Unterschied verstehen

Einschränkungen der Systemuhr

Testen Sie die Auflösung Ihres Systems

Best Practices

1. Wählen Sie die richtige Präzision

2. Konsequent aufbewahren

3. Dokumentieren Sie Ihre Wahl

4. Gehen Sie bei der Konvertierung vorsichtig vor

5. Präzision validieren

Häufige Fallstricke

1. Präzisionsverlust im Gleitkomma

2. Zeitzonenverwirrung

3. Überlaufprobleme

Verwandte Tools

Fazit