Unix Timestamp w JavaScripcie, Pythonie, PHP i Go — Przewodnik z kodami

Unix timestamp to liczba sekund od 1 stycznia 1970, 00:00:00 UTC. Prosty koncept, spójna implementacja — aż zauważysz, że JavaScript używa milisekund zamiast sekund, Python ma wiele funkcji zwracających nieco różne wartości, a znaczniki czasu PHP są podatne na ustawienia strefy czasowej w sposób, który zaskoczy niejedną osobę.

Konwerter Unix Timestamp obsługuje szybkie konwersje. Ten artykuł to przewodnik z kodami na wypadek, gdy musisz pracować ze znacznikami czasu programistycznie w wybranym języku.

JavaScript

JavaScript Date.now() zwraca milisekundy, nie sekundy. To jest najczęstsze źródło błędów ze znacznikami czasu, gdy frontend w JS rozmawia z API backendu oczekującym sekund.

// Bieżący timestamp w milisekundach
const ms = Date.now();                    // np. 1712505600000

// Bieżący timestamp w sekundach (liczba całkowita)
const secs = Math.floor(Date.now() / 1000);  // np. 1712505600

// Na podstawie obiektu Date
const d = new Date();
const secs2 = Math.floor(d.getTime() / 1000);

// Parsuj Unix timestamp (sekundy) do Date
const ts = 1712505600;
const date = new Date(ts * 1000);         // pomnóż przez 1000 aby uzyskać ms

// Formatuj do ISO 8601
const iso = date.toISOString();           // "2024-04-07T16:00:00.000Z"

// Pobierz poszczególne komponenty (UTC)
const year = date.getUTCFullYear();
const month = date.getUTCMonth() + 1;    // indeks od 0, dodaj 1
const day = date.getUTCDate();
const hours = date.getUTCHours();
const minutes = date.getUTCMinutes();

// Konwertuj ciąg daty do timestampu
const from_string = Math.floor(new Date("2024-04-07T16:00:00Z").getTime() / 1000);

Częsta pułapka: new Date(timestamp) bez pomnożenia przez 1000 zinterpretuje timestamp bazowany na sekundach jako milisekundy, tworząc datę z 1970 roku. Zawsze pomnóż przez 1000 tworząc Date z timestampu opartego na sekundach.

Wygaśnięcie tokenu: `js const expiresAt = Math.floor(Date.now() / 1000) + 86400; // za 24 godziny const isExpired = Math.floor(Date.now() / 1000) > expiresAt; `

Python

Python domyślnie używa sekund. time.time() zwraca liczbę zmiennoprzecinkową; użyj int() lub // aby uzyskać liczbę całkowitą.

import time
from datetime import datetime, timezone

# Bieżący timestamp (sekundy, liczba zmiennoprzecinkowa)
ts_float = time.time()             # np. 1712505600.123456

# Bieżący timestamp (sekundy, liczba całkowita)
ts_int = int(time.time())          # np. 1712505600

# Parsuj timestamp do datetime (UTC-aware)
ts = 1712505600
dt = datetime.fromtimestamp(ts, tz=timezone.utc)
# datetime(2024, 4, 7, 16, 0, tzinfo=timezone.utc)

# Formatuj do ciągu ISO 8601
iso = dt.isoformat()               # "2024-04-07T16:00:00+00:00"

# Datetime bez strefy (czas lokalny, unikaj w produkcji)
dt_local = datetime.fromtimestamp(ts)

# Konwertuj datetime do timestampu
from datetime import datetime, timezone
dt = datetime(2024, 4, 7, 16, 0, 0, tzinfo=timezone.utc)
ts_back = int(dt.timestamp())      # 1712505600

# 24 godziny od teraz
expires_at = int(time.time()) + 86400

Częsta pułapka: datetime.fromtimestamp() bez tz=timezone.utc używa czasu lokalnego systemu. Na serwerze w UTC to jest OK; na serwerze w innej strefie czasowej lub w kodzie użytkownika wprowadza offset strefy czasowej. Zawsze przekaż tz=timezone.utc, chyba że jawnie chcesz czas lokalny.

# Źle (zależy od strefy czasowej)
datetime.fromtimestamp(1712505600)

# Dobrze (zawsze UTC)
datetime.fromtimestamp(1712505600, tz=timezone.utc)

PHP

PHP time() zwraca sekundy, zgodnie z konwencją Unix. Najważniejsza rzecz do zapamiętania: funkcje data PHP są podatne na ustawienie date.timezone w php.ini. Jeśli jest ono błędne, sformatowane daty będą nieprawidłowe.

<?php

// Bieżący timestamp (sekundy)
$ts = time();                          // np. 1712505600

// Parsuj timestamp do sformatowanej daty (UTC)
echo date('Y-m-d H:i:s', $ts);        // wyjście zależy od ustawienia strefy czasowej

// Wymuś wyjście UTC niezależnie od php.ini
echo gmdate('Y-m-d H:i:s', $ts);      // "2024-04-07 16:00:00"

// ISO 8601 (UTC)
echo gmdate('c', $ts);                 // "2024-04-07T16:00:00+00:00"
// Lub ręcznie:
echo gmdate('Y-m-d\TH:i:s\Z', $ts);   // "2024-04-07T16:00:00Z"

// Konwertuj ciąg daty do timestampu (UTC)
$ts2 = strtotime('2024-04-07 16:00:00 UTC');

// Użyj DateTime aby mieć więcej kontroli
$dt = new DateTime('@' . $ts);         // @ oznacza Unix timestamp
$dt->setTimezone(new DateTimeZone('UTC'));
echo $dt->format('Y-m-d H:i:s');

// 24 godziny od teraz
$expires_at = time() + 86400;

// Sprawdź czy timestamp wygasł
$is_expired = time() > $expires_at;

Częsta pułapka: date() używa lokalnej strefy czasowej z date.timezone. gmdate() zawsze używa UTC. W aplikacji webowej używaj gmdate() dla timestampów i pól API, chyba że masz celowy powód aby używać czasu lokalnego.

PHP 8.x z DateTimeImmutable: `php $dt = new DateTimeImmutable('@' . $ts, new DateTimeZone('UTC')); echo $dt->format(DateTimeInterface::ATOM); // "2024-04-07T16:00:00+00:00" `

Go

Pakiet time w Go jest czysty i jawnie określa strefy czasowe. Wartość zerowa time.Time to 1 stycznia roku 1 (nie epoka Unix), więc sprawdzenia wartości zerowej różnią się od innych języków.

package main

import (
    "fmt"
    "time"
)

func main() {
    // Bieżący Unix timestamp (sekundy)
    ts := time.Now().Unix()               // int64

    // Bieżący Unix timestamp (milisekundy)
    ts_ms := time.Now().UnixMilli()       // int64

    // Bieżący Unix timestamp (nanosekundy)
    ts_ns := time.Now().UnixNano()        // int64

    // Parsuj Unix timestamp do time.Time (UTC)
    t := time.Unix(1712505600, 0).UTC()
    fmt.Println(t)                        // 2024-04-07 16:00:00 +0000 UTC

    // Formatuj do ISO 8601
    iso := t.Format(time.RFC3339)         // "2024-04-07T16:00:00Z"

    // Parsuj ciąg ISO 8601 do timestampu
    parsed, _ := time.Parse(time.RFC3339, "2024-04-07T16:00:00Z")
    ts2 := parsed.Unix()                  // 1712505600

    // 24 godziny od teraz
    expires_at := time.Now().Add(24 * time.Hour).Unix()

    // Sprawdź wygaśnięcie
    is_expired := time.Now().Unix() > expires_at

    _ = ts
    _ = ts_ms
    _ = ts_ns
    _ = ts2
    _ = is_expired
    fmt.Println(expires_at)
}

Kluczowa różnica od innych języków: Go time.Unix(ts, 0) przyjmuje dwa argumenty — sekundy i nanosekundy. Parametr nanosekundy to prawie zawsze 0 dla typowych Unix timestampów.

Częsta pułapka: Zapomnienie .UTC() po time.Unix() oznacza, że czas jest w lokalnej strefie czasowej maszyny. To zwykle jest OK w produkcji, jeśli serwer jest w UTC, ale niespójne między środowiskami. Dodaj .UTC() wyraźnie aby być bezpiecznym.

Porównywanie timestampów między językami

Rozpoznawanie sekund a milisekund

Gdy otrzymasz timestamp i nie jesteś pewny czy to sekundy czy milisekundy:

• 10 cyfr: sekundy (np. 1712505600 = kwiecień 2024)
• 13 cyfr: milisekundy (np. 1712505600000)

Granica: każdy timestamp powyżej 9 999 999 999 (10 miliardów) to prawdopodobnie milisekundy. Unix timestamp w sekundach przekroczył 1 700 000 000 we wrześniu 2023 i nie osiągnie 10 000 000 000 do listopada 2286.

Konwerter Unix Timestamp wykrywa format automatycznie i pokazuje reprezentację zarówno sekund jak i milisekund.