Timestamp Converter

Vad är en Unix-tidsstämpel?

En Unix-tidsstämpel (även kallad epoch-tid eller POSIX-tid) är antalet sekunder som har förflutit sedan den 1 januari 1970, 00:00:00 UTC. Detta datum kallas Unix epoch. Varje sekund som passerar ökar räknaren med ett, vilket ger varje ögonblick i tid en enkel heltalsrepresentation. En Unix-tidsstämpelkonverterare översätter mellan detta heltal och läsbara datumformat som ISO 8601, RFC 2822 eller lokalt formaterade strängar.

Unix-tidsstämplar är standardsättet att representera tid i datorsystem. Databaser lagrar kolumnerna created_at och updated_at som heltal eller millisekunderstidsstämplar. API-svar innehåller tidsstämplar för cache-huvuden (Expires, Last-Modified), JWT-anspråk (iat, exp, nbf) och händelseloggar. Loggfiler från nginx, syslog och applikationsramverk använder alla epoch-tid. Formatet är entydigt eftersom det alltid representerar UTC, utan tidszon eller sommartidskorrigering att feltolka.

Att manuellt konvertera mellan tidsstämplar och datum är felbenäget. Ett värde som 1711324800 ger ingen visuell ledtråd om vilket datum det representerar. Det här verktyget konverterar Unix-tidsstämplar till läsbara datum och datum tillbaka till tidsstämplar. Oavsett om du läser ett JWT exp-anspråk, felsöker en databasfråga eller kontrollerar en loggtidsstämpel hanterar det 10-siffriga (sekunder) och 13-siffriga (millisekunder) värden automatiskt.

Varför använda denna tidsstämpelkonverterare?

Att läsa råa Unix-tidsstämplar från loggar, databaser eller API-svar kräver antingen att man memorerar epoch-matematik eller skriver engångskod. Denna konverterare gör det i din webbläsare utan någon konfiguration. Oavsett om du behöver avkoda en JWT-utgångstid, granska en loggrad eller ställa in ett databas-TTL är resultatet ett klick bort. Verktyget identifierar automatiskt om ett värde är en 10-siffrig sekunderstidsstämpel eller en 13-siffrig millisekunderstidsstämpel, så du behöver aldrig dela manuellt med 1000. All bearbetning sker lokalt i din webbläsare. Ingen data lämnar din maskin, så tidsstämplar från interna system och känsliga loggar förblir privata.

Användningsfall för Timestamp Converter

Referenstabell för Unix-tidsstämplar

Tabellen nedan visar välkända Unix-tidsstämplar och deras motsvarande datum. Dessa värden är användbara för snabba rimlighetskontroller, testning och för att förstå intervallet för 32-bitars och 64-bitars tidsstämplar.

Jämförelse av datum- och tidsformat

Olika system och standarder representerar samma ögonblick i tid med olika strängformat. Tabellen jämför de vanligaste formaten du möter i API:er, loggar och databaser.

Kodexempel

Konvertera mellan Unix-tidsstämplar och datum i det språk du arbetar med. Varje exempel visar båda riktningarna: tidsstämpel till datum och datum till tidsstämpel.

// Current Unix timestamp in seconds
Math.floor(Date.now() / 1000)  // → 1711324800

// Unix timestamp to Date object
const date = new Date(1711324800 * 1000)
date.toISOString()             // → "2024-03-25T00:00:00.000Z"
date.toUTCString()             // → "Mon, 25 Mar 2024 00:00:00 GMT"

// Date string to Unix timestamp
Math.floor(new Date('2024-03-25T00:00:00Z').getTime() / 1000)
// → 1711324800

// Millisecond timestamps (common in JS APIs)
Date.now()                     // → 1711324800000 (ms)
Date.parse('2024-03-25')       // → 1711324800000 (ms)

import time
from datetime import datetime, timezone

# Current Unix timestamp
int(time.time())                                    # → 1711324800

# Unix timestamp to datetime
dt = datetime.fromtimestamp(1711324800, tz=timezone.utc)
dt.isoformat()                                      # → '2024-03-25T00:00:00+00:00'
dt.strftime('%Y-%m-%d %H:%M:%S %Z')                 # → '2024-03-25 00:00:00 UTC'

# Datetime string to Unix timestamp
dt = datetime.fromisoformat('2024-03-25T00:00:00+00:00')
int(dt.timestamp())                                  # → 1711324800

# Parse RFC 2822 dates (from email headers)
from email.utils import parsedate_to_datetime
parsedate_to_datetime('Mon, 25 Mar 2024 00:00:00 +0000').timestamp()
# → 1711324800.0

package main

import (
    "fmt"
    "time"
)

func main() {
    // Current Unix timestamp
    now := time.Now().Unix() // → 1711324800

    // Unix timestamp to time.Time
    t := time.Unix(1711324800, 0).UTC()
    fmt.Println(t.Format(time.RFC3339))
    // → 2024-03-25T00:00:00Z

    // Parse a date string to Unix timestamp
    parsed, _ := time.Parse(time.RFC3339, "2024-03-25T00:00:00Z")
    fmt.Println(parsed.Unix())
    // → 1711324800

    // Millisecond timestamp
    ms := time.Now().UnixMilli() // → 1711324800000
    fmt.Println(now, ms)
}

# Current Unix timestamp
date +%s                                    # → 1711324800

# Convert timestamp to human-readable date (GNU date)
date -d @1711324800                         # → Mon Mar 25 00:00:00 UTC 2024

# Convert timestamp to ISO 8601
date -d @1711324800 --iso-8601=seconds      # → 2024-03-25T00:00:00+00:00

# macOS (BSD date) — slightly different flags
date -r 1711324800                          # → Mon Mar 25 00:00:00 UTC 2024

# Date string to timestamp (GNU date)
date -d "2024-03-25 00:00:00 UTC" +%s       # → 1711324800

Vanliga frågor