Data w JavaScript: new Date, formatowanie i porównywanie

Obiekt Date to moment w czasie

Date w JavaScript reprezentuje jedną konkretną chwilę: wewnętrznie to po prostu liczba milisekund od 1 stycznia 1970 roku UTC (tak zwana „epoka Uniksa”). Cała reszta, czyli lata, miesiące, dni, strefy czasowe i formatowanie, to widok nałożony na tę liczbę.

const now = new Date();
console.log(now);
console.log(now.getTime());

now.getTime() to surowa liczba milisekund. Wszystko, co robi Date (porównywanie, dodawanie dni, formatowanie), sprowadza się do operacji na tej liczbie i ponownej jej interpretacji.

Zapamiętaj ten model. Date to nie „14 marca w Paryżu”. To uniwersalna chwila, którą można pokazać jako 14 marca w Paryżu albo 13 marca w Los Angeles, zależnie od strefy czasowej, przez którą na nią patrzysz.

Tworzenie dat

Są cztery główne sposoby na utworzenie obiektu Date:

const now = new Date();
const fromTimestamp = new Date(1_700_000_000_000);
const fromString = new Date("2026-03-14T09:30:00Z");
const fromParts = new Date(2026, 2, 14, 9, 30);

console.log(now.toISOString());
console.log(fromTimestamp.toISOString());
console.log(fromString.toISOString());
console.log(fromParts.toISOString());

Zwróć uwagę na dwie rzeczy:

• Konstruktor z częściami używa miesięcy numerowanych od zera. 2 oznacza marzec. Styczeń to 0. To stałe źródło błędów o jeden, ale przynajmniej API jest konsekwentne: wszędzie miesiące liczy się od 0.
• new Date("2026-03-14") (bez godziny) jest parsowane jako północ UTC. new Date("2026-03-14T09:30") (bez Z) jest parsowane jako czas lokalny. Ta asymetria to klasyczna pułapka.

Jeśli chcesz dostać „teraz” jako liczbę, wybierz Date.now(): nie tworzy obiektu.

const start = Date.now();
for (let i = 0; i < 1_000_000; i++) {}
const elapsed = Date.now() - start;
console.log(`${elapsed} ms`);

Date.now() to właściwe narzędzie do mierzenia upływu czasu, limitów czasu i wszystkiego, co nie wymaga obliczeń kalendarzowych.

Odczytywanie części daty

Mając obiekt Date, wyciągasz z niego składniki za pomocą getterów. Każdy występuje w dwóch wersjach: dla czasu lokalnego i dla UTC.

const d = new Date("2026-03-14T09:30:00Z");

console.log(d.getFullYear());      // local year
console.log(d.getMonth());         // 0-11, local
console.log(d.getDate());          // day of month, local
console.log(d.getDay());           // day of week, 0=Sunday
console.log(d.getHours());
console.log(d.getMinutes());

console.log(d.getUTCFullYear());
console.log(d.getUTCHours());

Wersje lokalne zależą od komputera, na którym działa kod. Jeśli zapisujesz albo porównujesz daty między użytkownikami i serwerami, jawnie wybierz UTC, bo inaczej będziesz ścigać błędy widma. Praktyczna zasada: gettery UTC do wszystkiego, co trafia do bazy danych albo logu; gettery lokalne do tego, co za chwilę pokażesz człowiekowi.

Nie używaj getYear(). To przestarzała metoda, która zwraca year - 1900 i istnieje tylko dla zgodności. Zawsze sięgaj po getFullYear().

Formatowanie dla ludzi

Unikaj date.toString() wszędzie tam, gdzie wynik ma znaczenie: jego format zależy od ustawień regionalnych i silnika. Warto znać dwa formatery.

Do standardowego tekstu czytelnego dla maszyn użyj toISOString():

const d = new Date("2026-03-14T09:30:00Z");
console.log(d.toISOString());

Tego formatu używasz przy logowaniu, zapisie do JSON i wysyłaniu przez sieć. Zawsze jest w UTC i zawsze jednoznaczny.

Do tekstu dla ludzi użyj Intl.DateTimeFormat albo metod toLocale*, które z niego korzystają:

const d = new Date("2026-03-14T09:30:00Z");

console.log(d.toLocaleDateString("en-US"));
console.log(d.toLocaleDateString("en-GB"));
console.log(d.toLocaleString("fr-FR", { dateStyle: "full", timeStyle: "short" }));

const formatter = new Intl.DateTimeFormat("en-US", {
    year: "numeric",
    month: "long",
    day: "numeric",
    timeZone: "America/New_York",
});
console.log(formatter.format(d));

Intl.DateTimeFormat obsługuje ustawienia regionalne, strefy czasowe i każdą kombinację pól, jakiej możesz potrzebować. Sięgnij po niego, zanim zaczniesz ręcznie składać ${year}-${month}-${day}: właśnie w takim sklejaniu tekstu żyją błędy z miesiącem przesuniętym o jeden.

Porównywanie dat

Dwa obiekty Date oznaczające tę samą chwilę nie są równe przez ===, bo === sprawdza tożsamość obiektów, a nie wartość. Porównuj zamiast tego ich znaczniki czasu:

const a = new Date("2026-03-14T09:30:00Z");
const b = new Date("2026-03-14T09:30:00Z");

console.log(a === b);              // false
console.log(a.getTime() === b.getTime());  // true
console.log(+a === +b);            // true - unary + coerces to number

Do ustalania kolejności operatory porównania działają bezpośrednio, bo zamieniają daty na liczby:

const earlier = new Date("2026-01-01");
const later = new Date("2026-06-01");

console.log(earlier < later);
console.log(later > earlier);

const differenceMs = later - earlier;
const differenceDays = differenceMs / (1000 * 60 * 60 * 24);
console.log(`${differenceDays} days apart`);

Odejmowanie daje różnicę w milisekundach. Podziel przez 1000 * 60 * 60 * 24, żeby dostać dni. Za pierwszym razem rozpisz tę stałą; z czasem 86_400_000 rozpoznasz na pierwszy rzut oka.

Arytmetyka na datach

Nie ma metody addDays. Idiomatyczny sposób to setDate, setMonth i podobne: przyjmują wartości spoza zakresu i poprawnie je przenoszą:

function addDays(date, days) {
    const result = new Date(date);
    result.setDate(result.getDate() + days);
    return result;
}

const today = new Date("2026-03-14");
console.log(addDays(today, 7).toISOString());
console.log(addDays(today, 30).toISOString());
console.log(addDays(today, -5).toISOString());

Dwie rzeczy warte podkreślenia:

• new Date(date) kopiuje datę. setDate modyfikuje obiekt, więc zawsze najpierw zrób kopię, bo inaczej zmienisz wartość należącą do kodu wywołującego.
• setDate(35) w miesiącu z 31 dniami automatycznie przechodzi na następny miesiąc. Tak samo setMonth(14) przesuwa rok. Dzięki temu arytmetyka jest dużo mniej bolesna, niż się wydaje.

Do wszystkiego bardziej złożonego (dni robocze, wydarzenia cykliczne, okresy uwzględniające miesiące) użyj biblioteki (date-fns, Luxon albo nadchodzącego API Temporal). Własne obliczenia kalendarzowe wykraczające poza „dodaj kilka dni” to grzęzawisko.

Strefy czasowe bez złudzeń

Strefy czasowe to największe pojedyncze źródło błędów z datami. Zasady, które warto sobie przyswoić:

• Date przechowuje chwilę w UTC. Strefa czasowa jest stosowana dopiero przy odczycie części albo formatowaniu.
• Strefa czasowa używana przez getHours(), getDate() itd. to lokalna strefa komputera, na którym działa kod. Serwery i przeglądarki często się w tym różnią.
• new Date("2026-03-14") (sama data) jest parsowane jako UTC. new Date("2026-03-14T00:00") (z godziną, bez strefy) jako czas lokalny. new Date(2026, 2, 14) (z części) też jako czas lokalny.

const fromString = new Date("2026-03-14");
const fromParts = new Date(2026, 2, 14);

console.log(fromString.toISOString());
console.log(fromParts.toISOString());

// These may differ by several hours depending on your timezone.

Gdy musisz pokazać datę w konkretnej strefie czasowej, przekaż timeZone do Intl.DateTimeFormat:

const d = new Date("2026-03-14T09:30:00Z");

const tokyo = new Intl.DateTimeFormat("en-US", {
    dateStyle: "short",
    timeStyle: "short",
    timeZone: "Asia/Tokyo",
});
const nyc = new Intl.DateTimeFormat("en-US", {
    dateStyle: "short",
    timeStyle: "short",
    timeZone: "America/New_York",
});

console.log(tokyo.format(d));
console.log(nyc.format(d));

Ta sama chwila, dwa widoki. Sam obiekt Date się nie zmienił.

Mały działający przykład

Wszystko razem: funkcja, która opisuje, jak dawno coś się wydarzyło:

function timeAgo(date) {
    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
    if (seconds < 60) return `${seconds}s ago`;

    const minutes = Math.floor(seconds / 60);
    if (minutes < 60) return `${minutes}m ago`;

    const hours = Math.floor(minutes / 60);
    if (hours < 24) return `${hours}h ago`;

    const days = Math.floor(hours / 24);
    return `${days}d ago`;
}

const past = new Date(Date.now() - 3 * 60 * 60 * 1000);
console.log(timeAgo(past));

const older = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000);
console.log(timeAgo(older));

Na wejściu znaczniki czasu, na wyjściu czytelny tekst. Tak wygląda 90% prawdziwego kodu z datami: odejmij dwie chwile, podziel przez jednostkę, zaokrąglij, sformatuj.

Co warto zapamiętać

• Date to chwila w UTC. Strefy czasowe pojawiają się przy odczycie albo formatowaniu.
• Używaj Date.now() do znaczników czasu, a new Date() do pracy z kalendarzem.
• toISOString() do zapisu i logów, Intl.DateTimeFormat dla użytkowników.
• Porównuj przez getTime() albo </>. Nigdy przez ===.
• Miesiące liczy się od 0. Uważaj na pułapkę przy parsowaniu tekstu z samą datą.
• Do poważnych obliczeń na datach użyj biblioteki.

Dalej: adresy URL i query stringi

Daty często trafiają do adresów URL: filtrowanie po zakresie dat, znacznik czasu jako parametr zapytania. Ręczne parsowanie i budowanie adresów URL jest tak samo podatne na błędy jak ręczne formatowanie dat, a biblioteka standardowa ma obiekt URL, który robi to porządnie. O tym jest następna strona.