Czas Epoch: Podstawa znaczników czasu Unix

December 04, 2025 • 5 min czytania

Written by Simon Meier

Czym dokładnie jest Epoch Time?

Jeśli kiedykolwiek pracowałeś z datami i czasem w programowaniu, prawdopodobnie natknąłeś się na znaczniki czasu Unix. Ale czym one właściwie są i dlaczego ich używamy?

Unix epoch time (zwany także czasem Unix, czasem POSIX lub po prostu "epoch") reprezentuje pojedynczy moment w czasie jako liczbę sekund, które upłynęły od 1 stycznia 1970 roku o północy UTC (Universal Coordinated Time). Ten konkretny moment jest znany jako "epoka Unix" lub "epoch zero".

Szybki przykład: Jeśli obecny znacznik czasu Unix to 1728773400, oznacza to, że dokładnie 1 728 773 400 sekund upłynęło od północy 1 stycznia 1970 roku.

Dlaczego 1 stycznia 1970?

Ta data może wydawać się arbitralna, ale została wybrana, gdy Unix był rozwijany na początku lat 70. w Bell Labs. Programiści potrzebowali spójnego punktu startowego dla swojego systemu śledzenia czasu, a 1 stycznia 1970 roku było blisko momentu, gdy pracowali nad projektem. Od tego czasu stało się to uniwersalnym standardem.

Zrozumienie formatu

Znaczniki czasu Unix występują w różnych formatach w zależności od potrzebnej precyzji:

Sekundy (10 cyfr): Standardowy format, jak 1728773400
Milisekundy (13 cyfr): Dla większej precyzji, jak 1728773400000
Mikrosekundy (16 cyfr): Dla ultra-precyzyjnego pomiaru czasu, jak 1728773400000000

Popularne interwały czasowe w sekundach

Zrozumienie tych popularnych interwałów pomoże ci bardziej intuicyjnie pracować ze znacznikami czasu:

Okres czasu	Sekundy	Szybkie obliczenie
1 godzina	3 600	60 × 60
1 dzień	86 400	24 × 3 600
1 tydzień	604 800	7 × 86 400
1 miesiąc (śr.)	2 629 743	30,44 × 86 400
1 rok (śr.)	31 556 926	365,24 × 86 400

Problem roku 2038 (Y2038)

Oto coś ważnego: wiele systemów przechowuje znaczniki czasu Unix jako 32-bitową liczbę całkowitą ze znakiem. To tworzy problem podobny do błędu Y2K.

32-bitowa liczba całkowita ze znakiem może liczyć tylko do 2 147 483 647 sekund. Gdy osiągniemy 19 stycznia 2038 roku o 03:14:07 UTC, ten licznik przekroczy zakres i zawinie się do liczby ujemnej, potencjalnie powodując awarie systemu i błędy.

Ważne: Nowoczesne systemy przechodzą na 64-bitowe znaczniki czasu, które nie przekroczą zakresu przez kolejne 292 miliardy lat. Upewnij się, że twoje aplikacje używają 64-bitowych liczb całkowitych do przechowywania znaczników czasu!

Pobieranie aktualnego Epoch Time

Każdy język programowania ma swój własny sposób na pobranie aktualnego znacznika czasu Unix. Oto najpopularniejsze metody:

Rozwój webowy

JavaScript

// Pobierz znacznik czasu w milisekundach, podziel przez 1000 dla sekund
const timestamp = Math.floor(Date.now() / 1000);

// Alternatywna metoda
const timestamp = Math.floor(new Date().getTime() / 1000);

PHP

// Proste i bezpośrednie
$timestamp = time();

// Używając DateTime (bardziej elastyczne)
$timestamp = (new DateTime())->getTimestamp();

Języki backendowe

Python

import time

# Pobierz aktualny znacznik czasu
timestamp = int(time.time())

# Używając modułu datetime
from datetime import datetime
timestamp = int(datetime.now().timestamp())

Java

// Zwraca milisekundy, podziel przez 1000 dla sekund
long timestamp = System.currentTimeMillis() / 1000;

// Używając Instant (Java 8+)
long timestamp = Instant.now().getEpochSecond();

// .NET Framework 4.6+ / .NET Core
long timestamp = DateTimeOffset.Now.ToUnixTimeSeconds();

// Starsze wersje
var epoch = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

Ruby

# Pobierz aktualny znacznik czasu
timestamp = Time.now.to_i

# Alternatywa
timestamp = Time.new.to_i

import "time"

// Pobierz aktualny znacznik czasu Unix
timestamp := time.Now().Unix()

// Dla milisekund
milliseconds := time.Now().UnixMilli()

Zapytania do bazy danych

MySQL

-- Pobierz aktualny znacznik czasu
SELECT UNIX_TIMESTAMP();

-- Pobierz znacznik czasu z konkretnej daty
SELECT UNIX_TIMESTAMP('2025-10-12 14:30:00');

PostgreSQL

-- Pobierz aktualny znacznik czasu
SELECT EXTRACT(EPOCH FROM NOW());

-- Z konkretnej daty
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-10-12 14:30:00');

SQLite

-- Pobierz aktualny znacznik czasu
SELECT STRFTIME('%s', 'now');

-- Z konkretnej daty
SELECT STRFTIME('%s', '2025-10-12 14:30:00');

Wiersz poleceń

Unix/Linux Shell

# Pobierz aktualny znacznik czasu
date +%s

# Konwertuj konkretną datę na znacznik czasu
date +%s -d "2025-10-12 14:30:00"

# Dla czasu UTC/GMT użyj -ud zamiast -d
date +%s -ud "2025-10-12 14:30:00"

PowerShell

# Pobierz aktualny znacznik czasu
[int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))

Konwersja Z Epoch na czytelną datę

Gdy masz już znacznik czasu Unix, często będziesz musiał przekonwertować go z powrotem na czytelny format daty:

JavaScript

// Konwertuj znacznik czasu na obiekt Date
const date = new Date(timestamp * 1000); // Pomnóż przez 1000 dla milisekund

// Sformatuj go
console.log(date.toLocaleString()); // Format lokalny
console.log(date.toISOString());    // Format ISO 8601

PHP

// Sformatuj znacznik czasu
$date = date('Y-m-d H:i:s', $timestamp);

// Format RFC 2822
$date = date('r', $timestamp);

// Używając DateTime
$date = (new DateTime())->setTimestamp($timestamp)->format('Y-m-d H:i:s');

Python

from datetime import datetime

# Konwertuj na obiekt datetime
dt = datetime.fromtimestamp(timestamp)

# Sformatuj go
formatted = dt.strftime('%Y-%m-%d %H:%M:%S')

# Dla UTC
dt_utc = datetime.utcfromtimestamp(timestamp)

MySQL

-- Konwertuj znacznik czasu na datetime
SELECT FROM_UNIXTIME(1728773400);

-- Z niestandardowym formatem
SELECT FROM_UNIXTIME(1728773400, '%Y-%m-%d %H:%i:%s');

Konwersja Z czytelnej daty na Epoch

Odwrotna operacja jest równie ważna:

JavaScript

// Parsuj string daty na znacznik czasu
const timestamp = Math.floor(new Date('2025-10-12 14:30:00').getTime() / 1000);

// Używając Date.parse()
const timestamp = Math.floor(Date.parse('October 12, 2025') / 1000);

PHP

// Parsuj większość angielskich tekstów dat
$timestamp = strtotime('15 November 2025');
$timestamp = strtotime('next Monday');
$timestamp = strtotime('+1 week');

// Używając DateTime
$timestamp = (new DateTime('2025-10-12 14:30:00'))->getTimestamp();

Python

from datetime import datetime
import time

# Parsuj string daty
dt = datetime.strptime('2025-10-12 14:30:00', '%Y-%m-%d %H:%M:%S')
timestamp = int(dt.timestamp())

# Dla UTC
import calendar
timestamp = calendar.timegm(time.strptime('2025-10-12 14:30:00', '%Y-%m-%d %H:%M:%S'))

Najlepsze praktyki

Podczas pracy ze znacznikami czasu Unix w twoich aplikacjach:

Zawsze używaj 64-bitowych liczb całkowitych, aby uniknąć problemu Y2038
Przechowuj znaczniki czasu w UTC w swojej bazie danych, konwertuj na czas lokalny tylko do wyświetlania
Bądź konsekwentny z precyzją (sekundy vs milisekundy) w całej swojej aplikacji
Dokumentuj swój format – wyjaśnij jasno, czy używasz sekund czy milisekund
Rozważ biblioteki uwzględniające strefy czasowe dla złożonych operacji na datach/czasie
Nigdy nie przechowuj czasu lokalnego jako znacznika czasu bez informacji o strefie czasowej

Podsumowanie

Znaczniki czasu Unix to fundamentalna koncepcja w programowaniu, którą każdy programista powinien rozumieć. Zapewniają prosty, uniwersalny sposób reprezentowania czasu, który działa we wszystkich systemach i językach programowania.

Niezależnie od tego, czy budujesz aplikację webową, pracujesz z bazami danych, czy po prostu musisz zaplanować zadania, zrozumienie epoch time znacznie ułatwi ci życie. Użyj naszego narzędzia Konwerter znaczników czasu Unix, aby szybko konwertować między znacznikami czasu a czytelnymi datami!

Wypróbuj teraz: Przejdź do naszego narzędzia konwertera, aby poćwiczyć pracę ze znacznikami czasu Unix w czasie rzeczywistym!