Guide

Zeitstempelformate verstehen

Einführung

Zeitstempel gibt es in verschiedenen Formaten und mit unterschiedlicher Genauigkeit. Das Verständnis dieser Formate ist für Entwickler, die mit Zeitdaten, APIs, Datenbanken und verteilten Systemen arbeiten, von entscheidender Bedeutung.

Kurze Zusammenfassung: Unix-Zeitstempel (Sekunden, Millisekunden, Mikrosekunden, Nanosekunden), ISO 8601-Zeichenfolgen und RFC 3339-Formate sind am häufigsten. Jedes dient unterschiedlichen Zwecken in der Softwareentwicklung.

Unix-Zeitstempelformate

Unix-Epoche (POSIX-Zeit)

Der Unix-Zeitstempel stellt die Zeit als Anzahl der Sekunden/Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC dar.

Unix Epoch Reference:
  Start Date: January 1, 1970, 00:00:00 UTC
  Current: January 1, 2026, 00:00:00 UTC
  Timestamp: 1735689600 (seconds)

Präzisionsstufen

Präzision	Beispiel	Größe	Allgemeine Verwendung
Sekunden	`1735689600`	10 Ziffern	Unix/Linux-Systeme
Millisekunden	`17356896000000`	13 Ziffern	JavaScript, Web-APIs
Mikrosekunden	`173568960000000000`	16 Ziffern	Hochpräzises Timing
Nanosekunden	`173568960000000000000`	19 Ziffern	Wissenschaftliches Rechnen

Codebeispiele: Unterschiedliche Genauigkeiten

// JavaScript uses milliseconds by default
const msTimestamp = Date.now(); // 17356896000000
const secTimestamp = Math.floor(Date.now() / 1000); // 1735689600
const nsTimestamp = Date.now() * 1000000; // 173568960000000000000

console.log('Milliseconds:', msTimestamp);
console.log('Seconds:', secTimestamp);
console.log('Nanoseconds:', nsTimestamp);

from datetime import datetime
import time

# Python supports multiple precisions
now = datetime.now(datetime.timezone.utc)
sec_timestamp = int(now.timestamp())
ms_timestamp = int(now.timestamp() * 1000)
us_timestamp = int(now.timestamp() * 1000000)
ns_timestamp = int(now.timestamp() * 1000000000)

print(f'Seconds: {sec_timestamp}')
print(f'Milliseconds: {ms_timestamp}')
print(f'Microseconds: {us_timestamp}')
print(f'Nanoseconds: {ns_timestamp}')

import java.time.Instant;

// Java supports multiple precisions
Instant now = Instant.now();
long secTimestamp = now.getEpochSecond(); // 1735689600
long msTimestamp = now.toEpochMilli(); // 17356896000000
int nsTimestamp = now.getNano(); // Nanoseconds within second

System.out.println("Seconds: " + secTimestamp);
System.out.println("Milliseconds: " + msTimestamp);
System.out.println("Nanoseconds: " + nsTimestamp);

ISO 8601-Format

Definition

ISO 8601 ist ein internationaler Standard zur Darstellung von Datum und Uhrzeit. Es ist das am weitesten verbreitete Format zum Speichern und Austauschen von Zeitstempeln.

Formatvarianten

Basic ISO 8601 Formats:
  1. Calendar Date: 2026-01-01
  2. Date and Time: 2026-01-01T12:00:00
  3. With Time Zone: 2026-01-01T12:00:00+08:00
  4. UTC (Z notation): 2026-01-01T12:00:00Z
  5. With Fractional Seconds: 2026-01-01T12:00:00.123Z
  6. With Milliseconds: 2026-01-01T12:00:00.123Z
  7. With Nanoseconds: 2026-01-01T12:00:00.123456789Z

Aufschlüsselung von ISO 8601

Format: YYYY-MM-DDThh:mm:ss.sssTZD

Components:
  YYYY - Four-digit year (2026)
  MM - Two-digit month (01)
  DD - Two-digit day (01)
  T - Separator between date and time
  hh - Two-digit hour (00-23)
  mm - Two-digit minute (00-59)
  ss - Two-digit second (00-59)
  sss - Fractional seconds (optional)
  TZD - Time zone designator (Z, +08:00, -05:00)

Codebeispiele: ISO 8601

// JavaScript has built-in ISO 8601 support
const now = new Date();
const isoString = now.toISOString(); // "2026-01-01T12:00:00.000Z"

// Parse ISO 8601
const date = new Date('2026-01-01T12:00:00Z');

console.log('ISO 8601:', isoString);
console.log('Parsed:', date.toISOString());

from datetime import datetime, timezone

# Generate ISO 8601
now_utc = datetime.now(timezone.utc)
iso_string = now_utc.isoformat() # "2026-01-01T12:00:00+00:00"

# Parse ISO 8601
parsed_date = datetime.fromisoformat('2026-01-01T12:00:00+00:00')

print(f'ISO 8601: {iso_string}')
print(f'Parsed: {parsed_date.isoformat()}')

import java.time.Instant;
import java.time.format.DateTimeFormatter;

// Generate ISO 8601
Instant now = Instant.now();
String isoString = now.toString(); // "2026-01-01T12:00:00:00Z"

// Parse ISO 8601
Instant parsed = Instant.parse("2026-01-01T12:00:00:00Z");

System.out.println("ISO 8601: " + isoString);
System.out.println("Parsed: " + parsed);

RFC 3339-Format

Definition

RFC 3339 ist eine Teilmenge von ISO 8601, die speziell für Internetprotokolle und E-Mail-Standards entwickelt wurde.

Unterschiede zu ISO 8601

Funktion	ISO 8601	RFC 3339
Formatieren	Mehrere Varianten	Festes Format
Zeitzone	Kann Offset oder Z	verwenden Kann Offset oder Z
Anwendungen	Allzweck	Internetprotokolle (HTTP, E-Mail)
Sekundenbruchteile	Optional	Optional
Beispiel	`2026-01-01T12:00:00+08:00`	`2026-01-01T12:00:00+08:00`

Hinweis: RFC 3339 ist fast identisch mit ISO 8601. In der Praxis werden sie für Internetanwendungen austauschbar verwendet.

Codebeispiele: RFC 3339

// RFC 3339 is similar to ISO 8601
const now = new Date();
const rfc3339String = now.toISOString(); // "2026-01-01T12:00:00.000Z"

// RFC 3339 commonly used in HTTP headers
const httpDate = now.toUTCString(); // "Wed, 01 Jan 2026 12:00:00 GMT"

console.log('RFC 3339:', rfc3339String);
console.log('HTTP Date:', httpDate);

from datetime import datetime, timezone
import email.utils

# Generate RFC 3339 (same as ISO 8601)
now_utc = datetime.now(timezone.utc)
rfc3339_string = now_utc.isoformat() # "2026-01-01T12:00:00+00:00"

# Generate HTTP date format
http_date = email.utils.format_datetime(now_utc)

print(f'RFC 3339: {rfc3339_string}')
print(f'HTTP Date: {http_date}')

Formatkonvertierung

Unix-Zeitstempel ↔ ISO 8601

// Unix to ISO 8601
function unixToIso(unixTimestamp, precision = 'ms') {
  let ts = unixTimestamp;
  if (precision === 's') {
    ts = unixTimestamp * 1000;
  } else if (precision === 'us') {
    ts = unixTimestamp / 1000;
  } else if (precision === 'ns') {
    ts = unixTimestamp / 1000;
  } else if (precision === 'ns') {
    ts = unixTimestamp / 1000000;
  }
  return new Date(ts).toISOString();
}

// ISO 8601 to Unix
function isoToUnix(isoString) {
  return Math.floor(new Date(isoString).getTime() / 1000);
}

// Examples
const unixTs = 1735689600;
const isoStr = unixToIso(unixTs); // "2026-01-01T00:00:00.000Z"
const backToUnix = isoToUnix(isoStr); // 1735689600

console.log('Unix → ISO:', isoStr);
console.log('ISO → Unix:', backToUnix);

from datetime import datetime, timezone

def unix_to_iso(unix_timestamp, precision='s'):
    """Convert Unix timestamp to ISO 8601 string"""
    ts = unix_timestamp
    if precision == 's':
        ts = unix_timestamp
    elif precision == 'ms':
        ts = unix_timestamp / 1000
    elif precision == 'us':
        ts = unix_timestamp / 1000
    elif precision == 'ns':
        ts = unix_timestamp / 1000000
    elif precision == 'ns':
        ts = unix_timestamp / 1000000000

    dt = datetime.fromtimestamp(ts, timezone.utc)
    return dt.isoformat()

def iso_to_unix(iso_string):
    """Convert ISO 8601 string to Unix timestamp"""
    dt = datetime.fromisoformat(iso_string)
    return int(dt.timestamp())

# Examples
unix_ts = 1735689600
iso_str = unix_to_iso(unix_ts)  # "2026-01-01T00:00:00+00:00"
back_to_unix = iso_to_unix(iso_str)  # 1735689600

print(f'Unix → ISO: {iso_str}')
print(f'ISO → Unix: {back_to_unix}')

Präzisionserkennung

Erkennen der Präzision von Unix-Zeitstempeln

function detectPrecision(timestamp) {
  const str = timestamp.toString();

  if (str.length === 10) {
    return 'seconds';
  } else if (str.length === 13) {
    return 'milliseconds';
  } else if (str.length === 16) {
    return 'microseconds';
  } else if (str.length === 19) {
    return 'nanoseconds';
  }

  return 'unknown';
}

// Examples
console.log(detectPrecision(1735689600)); // "seconds"
console.log(detectPrecision(17356896000000)); // "milliseconds"
console.log(detectPrecision(173568960000000000)); // "microseconds"
console.log(detectPrecision(173568960000000000000)); // "nanoseconds"

def detect_precision(timestamp):
    """Detect Unix timestamp precision"""
    str_ts = str(int(timestamp))

    if len(str_ts) == 10:
        return 'seconds'
    elif len(str_ts) == 13:
        return 'milliseconds'
    elif len(str_ts) == 16:
        return 'microseconds'
    elif len(str_ts) == 19:
        return 'nanoseconds'

    return 'unknown'

# Examples
print(detect_precision(1735689600))  # "seconds"
print(detect_precision(173568960000000))  # "milliseconds"
print(detect_precision(173568960000000000))  # "microseconds"
print(detect_precision(173568960000000000000))  # "nanoseconds"

Vergleichstabelle

Unix-Zeitstempel vs. ISO 8601 vs. RFC 3339

Aspekt	Unix-Zeitstempel	ISO 8601	RFC 3339
Formatieren	Zahl (Ganzzahl/Float)	Zeichenfolge	Zeichenfolge
Von Menschen lesbar	Nein	Ja	Ja
Zeitzoneninformationen	Nein (implizite UTC)	Ja (optional)	Ja (optional)
Präzision	Konfigurierbar	Konfigurierbar	Konfigurierbar
Speichergröße	4-8 Byte	20-30 Byte	20-30 Byte
Datenbankunterstützung	Universell	Universell	Universell
Allgemeine Verwendung	Systemzeitstempel	APIs, JSON, Datenbanken	HTTP, E-Mail, APIs
Beispiel	`1735689600`	`2026-01-01T12:00:00:00Z`	`2026-01-01T12:00:00:00Z`

Empfehlung: Verwenden Sie Unix-Zeitstempel für die interne Speicherung und Berechnungen. Verwenden Sie ISO 8601/RFC 3339 für APIs, Datenaustausch und für Menschen lesbare Formate.

Best Practices

Lagerung

Verwenden Sie Unix-Zeitstempel in Datenbanken für eine effiziente Speicherung und Indizierung
Verwenden Sie ISO 8601 für externe APIs und Datenaustausch
Geben Sie bei der Anzeige für Benutzer immer Zeitzonen an
Dokumentformat in Datenbankschemakommentaren

-- Best practice: Store Unix timestamp in database
CREATE TABLE events (
  id INT PRIMARY KEY,
  event_timestamp BIGINT,  -- Unix timestamp in milliseconds
  description TEXT,
  created_at TIMESTAMP WITHOUT TIME ZONE DEFAULT NOW()
);

API-Antworten

Verwenden Sie ISO 8601 für API-Antworttexte
Einschließen des Unix-Zeitstempels für den programmgesteuerten Zugriff
Geben Sie die Zeitzone deutlich an in den Antworten

{
  "event": {
    "id": 123,
    "timestamp": 173568960000000,
    "iso8601": "2026-01-01T12:00:00:00Z",
    "timezone": "UTC",
    "human_readable": "January 1, 2026 at 12:00:00 AM UTC"
  }
}

Fehlerbehandlung

Format validieren vor dem Parsen
Verwaltung von Schaltsekunden in hochpräzisen Anwendungen
Anmutige Verschlechterung für unbekannte Formate

// Validate ISO 8601 format
function isValidISO8601(str) {
  const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}:\d{2})?$/;
  return isoRegex.test(str);
}

// Handle parsing errors
function safeParseISO8601(str) {
  try {
    return new Date(str);
  } catch (error) {
    console.error('Invalid ISO 8601 format:', str);
    return new Date(); // Fallback to current time
  }
}

Häufige Fallstricke

Fallstrick 1: Angenommen, der Unix-Zeitstempel beträgt immer Sekunden

// ❌ Wrong: Always dividing by 1000
const timestamp = Date.now();
const wrongDate = new Date(timestamp / 1000); // Incorrect division

// ✅ Right: Check precision first
const date = new Date(timestamp); // Date accepts milliseconds directly

Fallstrick 2: Zeitzonen ignorieren

// ❌ Wrong: Creating local time without timezone
const localTime = new Date('2026-01-01T12:00:00'); // Ambiguous

// ✅ Right: Specify timezone explicitly
const utcTime = new Date('2026-01-01T12:00:00Z'); // Clear UTC
const tokyoTime = new Date('2026-01-01T12:00:00+09:00'); // Tokyo time

Fallstrick 3: Formate mischen

// ❌ Wrong: Inconsistent formats in API
{
  "timestamp": 1735689600,
  "date": "01/01/2026",
  "time": "12:00 PM",
  "datetime": "2026-01-01 12:00"
}

// ✅ Right: Consistent ISO 8601 format
{
  "timestamp": 1735689600,
  "iso8601": "2026-01-01T12:00:00:00Z",
  "timezone": "UTC"
}

FAQ

F: Was ist der Unterschied zwischen ISO 8601 und RFC 3339?

A: RFC 3339 ist eine Teilmenge von ISO 8601, die für Internetprotokolle entwickelt wurde. In der Praxis sind sie nahezu identisch, RFC 3339 hat jedoch strengere Formatregeln.

F: Woher weiß ich, ob ein Unix-Zeitstempel in Sekunden oder Millisekunden vorliegt?

A: Ziffern zählen: 10 Ziffern = Sekunden, 13 Ziffern = Millisekunden. Sie können auch das Jahr überprüfen (Sekunden = 1970+, Millisekunden = 1970+).

F: Welche Präzision sollte ich für meine Anwendung verwenden?

A: Verwenden Sie Millisekunden für allgemeine Webanwendungen (JavaScript-Standard), Sekunden für die Datenbankspeichereffizienz oder Mikrosekunden/Nanosekunden für hochpräzises Timing.

F: Unterstützt ISO 8601 Zeitzonen?

A: Ja, ISO 8601 unterstützt Zeitzonenversätze (+08:00) und Z-Notation für UTC.

F: Wie gehe ich mit Zeitzonen mit Unix-Zeitstempeln um?

A: Unix-Zeitstempel sind immer UTC. Konvertieren Sie die Zeit nur dann in die Ortszeit, wenn sie Benutzern angezeigt wird, die ihre Zeitzoneneinstellungen verwenden.

F: Wie hoch ist der maximale Unix-Zeitstempelwert?

A: Für 64-Bit-Systeme: Der 19. Januar 2038 (Jahr 2038-Problem) ist kein Problem. Das theoretische Maximum liegt Milliarden Jahre in der Zukunft.

Zeitstempelformate verstehen

Einführung

Unix-Zeitstempelformate

Unix-Epoche (POSIX-Zeit)

Präzisionsstufen

Codebeispiele: Unterschiedliche Genauigkeiten

ISO 8601-Format

Definition

Formatvarianten

Aufschlüsselung von ISO 8601

Codebeispiele: ISO 8601

RFC 3339-Format

Definition

Unterschiede zu ISO 8601

Codebeispiele: RFC 3339

Formatkonvertierung

Unix-Zeitstempel ↔ ISO 8601

Präzisionserkennung

Erkennen der Präzision von Unix-Zeitstempeln

Vergleichstabelle

Unix-Zeitstempel vs. ISO 8601 vs. RFC 3339

Best Practices

Lagerung

API-Antworten

Fehlerbehandlung

Häufige Fallstricke

Fallstrick 1: Angenommen, der Unix-Zeitstempel beträgt immer Sekunden

Fallstrick 2: Zeitzonen ignorieren

Fallstrick 3: Formate mischen

Verwandte Tools

FAQ

F: Was ist der Unterschied zwischen ISO 8601 und RFC 3339?

F: Woher weiß ich, ob ein Unix-Zeitstempel in Sekunden oder Millisekunden vorliegt?

F: Welche Präzision sollte ich für meine Anwendung verwenden?

F: Unterstützt ISO 8601 Zeitzonen?

F: Wie gehe ich mit Zeitzonen mit Unix-Zeitstempeln um?

F: Wie hoch ist der maximale Unix-Zeitstempelwert?