Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Obiekt Date i praca z czasem

10 min czytania ·
W tej lekcji7

W centrum dowodzenia Parku Jurajskiego, Ray Arnold monitoruje harmonogramy karmienia dinozaurów. "Czas to kluczowy element bezpieczeństwa," wyjaśnia. "Muszę wiedzieć dokładnie kiedy każdy dinozaur był karmiony, kiedy będzie następne karmienie, i ile czasu minęło od ostatniej inspekcji ogrodzenia." Czas w JavaScripcie potrafi jednak zaskoczyć: czerwiec ma tu numer 5, a ta sama data zapisana na dwa sposoby może wskazać różne godziny. Rozbrójmy te pułapki po kolei.

Tworzenie obiektów Date

Obiekt Date tworzysz konstruktorem new Date(). Bez argumentów dostajesz bieżący moment, a z liczbami konkretną datę złożoną z roku, miesiąca i dnia:

// Aktualna data i czas
const now = new Date();
console.log(now); // np. "Sat Jun 15 2024 14:30:00 GMT+0200"

// Z konkretną datą (uwaga: miesiące są od 0!)
const jurassicOpening = new Date(1993, 5, 11); // 11 czerwca 1993
console.log(jurassicOpening);

// Z pełną datą i czasem
const incident = new Date(1993, 5, 11, 20, 30, 0);
// 11 czerwca 1993, 20:30:00

Zwróć uwagę na piątkę: miesiące liczone są od zera, więc styczeń to 0, a czerwiec 5. Dni miesiąca liczą się już normalnie, od 1. To najczęstsza pułapka Date.

Datę odtworzysz też z tekstu albo z liczby milisekund, czyli znacznika czasu (timestamp):

// Z ciągu tekstowego (ISO 8601)
const dateFromString = new Date("2024-06-15T14:30:00");
// Sama data bez godziny jest traktowana jako UTC!
const dateOnly = new Date("2024-06-15");

// Z timestampa (milisekundy od 1 stycznia 1970)
const fromTimestamp = new Date(1718451000000);
const epoch = new Date(0); // 1 stycznia 1970, 00:00:00 UTC

// Timestamp obecnego momentu
const timestamp = Date.now();
console.log(timestamp); // np. 1718451000000

Tekst z datą i godziną, ale bez strefy, jest czytany jako czas lokalny, a sama data - jako północ UTC. W Polsce dateOnly pokaże więc 1 albo 2 w nocy, zależnie od pory roku. Date.now() zwraca liczbę milisekund od 1 stycznia 1970, a nie obiekt Date.

Pobieranie składników daty

Gdy data już istnieje, metody get... wyciągają z niej pojedyncze składniki - rok, miesiąc, dzień czy godzinę:

const feedingTime = new Date("2024-06-15T08:30:00");

// Pobieranie składników
console.log(feedingTime.getFullYear());    // 2024
console.log(feedingTime.getMonth());       // 5 (czerwiec - miesiące od 0!)
console.log(feedingTime.getDate());        // 15 (dzień miesiąca)
console.log(feedingTime.getDay());         // 6 (sobota - dni od 0, niedziela = 0)
console.log(feedingTime.getHours());       // 8
console.log(feedingTime.getMinutes());     // 30
console.log(feedingTime.getSeconds());     // 0
console.log(feedingTime.getMilliseconds()); // 0

// Timestamp
console.log(feedingTime.getTime()); // milisekundy od 1970

// Wersje UTC
console.log(feedingTime.getUTCHours()); // godzina w UTC

getDate() zwraca dzień miesiąca, a getDay() dzień tygodnia liczony od niedzieli jako 0 - łatwo je pomylić. Metody pracują w strefie czasowej komputera, a wersje z UTC w nazwie w czasie uniwersalnym.

Ustawianie składników daty

Metody set... działają odwrotnie i zmieniają datę w miejscu, bo obiekt Date jest mutowalny:

const nextFeeding = new Date();

// Ustawianie składników
nextFeeding.setFullYear(2024);
nextFeeding.setMonth(6);          // Lipiec (miesiące od 0!)
nextFeeding.setDate(20);
nextFeeding.setHours(9);
nextFeeding.setMinutes(0);
nextFeeding.setSeconds(0);

// Ustawienie wielu naraz
nextFeeding.setFullYear(2024, 6, 20); // rok, miesiąc, dzień

console.log(nextFeeding);

setFullYear() przyjmuje od razu rok, miesiąc i dzień. Settery same przenoszą nadmiar: setDate(32) w czerwcu da 2 lipca, a dodanie godzin przez setHours() przejdzie przez północ do kolejnego dnia.

Formatowanie daty

Wbudowane metody

Do wyświetlania daty obiekt Date ma kilka gotowych metod. Część daje stały format, a część zależy od ustawień języka:

const event = new Date("2024-06-15T14:30:00");

// Różne formaty
console.log(event.toString());
// "Sat Jun 15 2024 14:30:00 GMT+0200 (Central European Summer Time)"

console.log(event.toDateString());
// "Sat Jun 15 2024"

console.log(event.toTimeString());
// "14:30:00 GMT+0200 (Central European Summer Time)"

console.log(event.toISOString());
// "2024-06-15T12:30:00.000Z" (UTC)

console.log(event.toLocaleDateString());
// "15.06.2024" (zależy od locale)

console.log(event.toLocaleTimeString());
// "14:30:00" (zależy od locale)

console.log(event.toLocaleString());
// "15.06.2024, 14:30:00"

toISOString() zawsze podaje czas UTC, dlatego 14:30 w polskim lecie staje się 12:30 z literą Z. Wyniki metod toLocale... zależą od języka przeglądarki - komentarze pokazują polskie ustawienia.

Intl.DateTimeFormat - zaawansowane formatowanie

Pełną kontrolę nad formatem daje Intl.DateTimeFormat. Podajesz język i opcje, a formatter sam zadba o nazwy dni i miesięcy:

const date = new Date("2024-06-15T14:30:00");

// Polski format
const plFormatter = new Intl.DateTimeFormat('pl-PL', {
  weekday: 'long',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(plFormatter.format(date));
// "sobota, 15 czerwca 2024"

// Format z czasem
const fullFormatter = new Intl.DateTimeFormat('pl-PL', {
  dateStyle: 'full',
  timeStyle: 'short'
});
console.log(fullFormatter.format(date));
// "sobota, 15 czerwca 2024 14:30"

// Krótki format
const shortFormatter = new Intl.DateTimeFormat('pl-PL', {
  dateStyle: 'short'
});
console.log(shortFormatter.format(date));
// "15.06.2024"

// Skrót: toLocaleDateString() przyjmuje te same opcje
console.log(date.toLocaleDateString('pl-PL', { weekday: 'long' }));
// "sobota"

Formatter tworzysz raz i używasz wielokrotnie. dateStyle i timeStyle to gotowe zestawy opcji, a toLocaleDateString() przyjmuje te same opcje do jednorazowego formatu.

Obliczenia na datach

Różnica między datami

Odejmowanie dwóch dat daje liczbę milisekund, bo JavaScript zamienia każdą datę na jej znacznik czasu:

const lastFeeding = new Date("2024-06-15T08:00:00");
const now = new Date("2024-06-15T14:30:00");

// Różnica w milisekundach
const diffMs = now - lastFeeding;
console.log(diffMs); // 23400000

// Konwersja na różne jednostki
const diffSeconds = diffMs / 1000;
const diffMinutes = diffMs / (1000 * 60);
const diffHours = diffMs / (1000 * 60 * 60);
const diffDays = diffMs / (1000 * 60 * 60 * 24);

console.log(`Minęło ${diffHours} godzin od ostatniego karmienia`);
// "Minęło 6.5 godzin od ostatniego karmienia"

// Porównania: < i > działają, === porównuje obiekty
console.log(lastFeeding < now); // true
console.log(new Date("2024-06-15T08:00:00") === lastFeeding); // false
console.log(new Date("2024-06-15T08:00:00").getTime() === lastFeeding.getTime()); // true

Dzielenie przez 1000, 60 i 60 zamienia milisekundy na godziny. Operatory < i > porównują daty poprawnie, ale === sprawdza, czy to ten sam obiekt - osobne daty porównuj przez getTime().

Dodawanie/odejmowanie czasu

Czas dodajesz, doliczając milisekundy do znacznika czasu albo przesuwając składnik setterem. Funkcja pomocnicza zamyka oba warianty w jednym miejscu:

const baseDate = new Date("2024-06-15T08:00:00");

// Dodaj 3 godziny
const plus3Hours = new Date(baseDate.getTime() + 3 * 60 * 60 * 1000);
console.log(plus3Hours.toLocaleTimeString()); // "11:00:00"

// Dodaj 7 dni
const plus7Days = new Date(baseDate);
plus7Days.setDate(plus7Days.getDate() + 7);
console.log(plus7Days.toLocaleDateString()); // "22.06.2024"

// Odejmij 1 miesiąc
const minus1Month = new Date(baseDate);
minus1Month.setMonth(minus1Month.getMonth() - 1);
console.log(minus1Month.toLocaleDateString()); // "15.05.2024"

// Funkcja pomocnicza do dodawania czasu
function addTime(date, amount, unit) {
  const result = new Date(date);

  switch(unit) {
    case 'seconds':
      result.setSeconds(result.getSeconds() + amount);
      break;
    case 'minutes':
      result.setMinutes(result.getMinutes() + amount);
      break;
    case 'hours':
      result.setHours(result.getHours() + amount);
      break;
    case 'days':
      result.setDate(result.getDate() + amount);
      break;
    case 'months':
      result.setMonth(result.getMonth() + amount);
      break;
    case 'years':
      result.setFullYear(result.getFullYear() + amount);
      break;
  }

  return result;
}

console.log(addTime(baseDate, 2, 'hours').toLocaleTimeString()); // "10:00:00"

Każdy przykład zaczyna od kopii new Date(baseDate), więc baseDate zostaje nietknięta. Do dni i miesięcy polecam settery, bo milisekundy nie wiedzą nic o zmianie czasu, gdy doba ma 23 lub 25 godzin.

Praktyczne przykłady w Parku Jurajskim

1. System harmonogramu karmienia

Pierwszy harmonogram trzyma w Map konkretne godziny karmienia i liczy, ile czasu zostało do posiłku:

class FeedingScheduler {
  constructor() {
    this.schedule = new Map();
  }

  scheduleFeed(dinoId, feedingTime) {
    this.schedule.set(dinoId, {
      scheduledTime: new Date(feedingTime),
      status: 'pending'
    });
  }

  getNextFeeding(dinoId) {
    const feeding = this.schedule.get(dinoId);
    if (!feeding) return null;

    const now = new Date();
    const timeUntil = feeding.scheduledTime - now;

    if (timeUntil < 0) {
      return { status: 'overdue', overdue: this.formatDuration(-timeUntil) };
    }

    return {
      status: 'scheduled',
      timeUntil: this.formatDuration(timeUntil),
      scheduledTime: feeding.scheduledTime.toLocaleString('pl-PL')
    };
  }

  formatDuration(ms) {
    const hours = Math.floor(ms / (1000 * 60 * 60));
    const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60));

    if (hours > 0) {
      return `${hours}h ${minutes}min`;
    }
    return `${minutes}min`;
  }
}

const scheduler = new FeedingScheduler();
scheduler.scheduleFeed('TREX-001', '2024-06-15T09:00:00');
console.log(scheduler.getNextFeeding('TREX-001'));

Gdy termin minął, różnica dat jest ujemna - stąd status overdue, który zobaczysz przy dacie z przykładu. formatDuration() rozbija milisekundy na godziny i minuty operatorem reszty %.

2. Harmonogram co kilka godzin

Drugi wariant zna tylko odstęp między posiłkami. Następny termin to czas ostatniego karmienia plus odstęp w milisekundach:

class FeedingScheduler {
  constructor() {
    this.schedules = new Map();
  }

  addSchedule(dinoId, feedingIntervalHours) {
    this.schedules.set(dinoId, {
      lastFed: new Date(),
      interval: feedingIntervalHours,
      nextFeeding: new Date(Date.now() + feedingIntervalHours * 3600000)
    });
  }

  getNextFeeding(dinoId) {
    const schedule = this.schedules.get(dinoId);
    if (!schedule) return null;
    return schedule.nextFeeding;
  }

  isOverdue(dinoId) {
    const schedule = this.schedules.get(dinoId);
    if (!schedule) return false;
    return new Date() > schedule.nextFeeding;
  }

  getOverdueDinosaurs() {
    const overdue = [];
    const now = new Date();

    for (const [dinoId, schedule] of this.schedules) {
      if (now > schedule.nextFeeding) {
        const overdueHours = (now - schedule.nextFeeding) / 3600000;
        overdue.push({
          dinoId,
          overdueBy: `${overdueHours.toFixed(1)} godz.`,
          nextFeeding: schedule.nextFeeding
        });
      }
    }

    // Najdłużej czekający dinozaur na początku listy
    return overdue.sort((a, b) => a.nextFeeding - b.nextFeeding);
  }

  recordFeeding(dinoId) {
    const schedule = this.schedules.get(dinoId);
    if (!schedule) return false;

    const now = new Date();
    schedule.lastFed = now;
    schedule.nextFeeding = new Date(now.getTime() + schedule.interval * 3600000);

    console.log(`${dinoId} nakarmiony o ${now.toLocaleTimeString()}. Następne karmienie: ${schedule.nextFeeding.toLocaleTimeString()}`);
    return true;
  }
}

isOverdue() porównuje daty zwykłym >, a getOverdueDinosaurs() przechodzi po mapie pętlą for...of i sortuje wynik od najdłużej czekających. recordFeeding() odlicza nowy odstęp od chwili karmienia.

Każdy gatunek dostaje własny rytm karmienia:

// Użycie
const scheduler = new FeedingScheduler();
scheduler.addSchedule("TREX-001", 8);   // T-Rex co 8 godzin
scheduler.addSchedule("RAPTOR-01", 6);  // Raptor co 6 godzin
scheduler.addSchedule("BRACHIOSAURUS", 4); // Roślinożerca co 4 godziny

const overdue = scheduler.getOverdueDinosaurs();
if (overdue.length > 0) {
  console.log("Spóźnione karmienia:", overdue);
}

Zaraz po dodaniu nikt nie jest spóźniony, więc nic się nie wypisze - spóźnienia pojawią się, gdy minie odstęp bez recordFeeding().

3. Względne formatowanie czasu

Zwiedzających nie interesuje znacznik czasu, tylko komunikat w stylu "5 minut temu". Można go policzyć ręcznie albo oddać tę pracę Intl.RelativeTimeFormat:

function formatRelativeTime(date) {
  const now = new Date();
  const diff = now - new Date(date);

  const seconds = Math.floor(diff / 1000);
  const minutes = Math.floor(seconds / 60);
  const hours = Math.floor(minutes / 60);
  const days = Math.floor(hours / 24);

  if (seconds < 60) return 'przed chwilą';
  if (minutes < 60) return `${minutes} min temu`;
  if (hours < 24) return `${hours} godz. temu`;
  if (days < 7) return `${days} dni temu`;

  return new Date(date).toLocaleDateString('pl-PL');
}

// Lub z użyciem Intl.RelativeTimeFormat
function formatRelativeTimeIntl(date) {
  const rtf = new Intl.RelativeTimeFormat('pl', { numeric: 'auto' });
  const diff = new Date(date) - new Date();

  const seconds = Math.round(diff / 1000);
  const minutes = Math.round(seconds / 60);
  const hours = Math.round(minutes / 60);
  const days = Math.round(hours / 24);

  if (Math.abs(seconds) < 60) return rtf.format(seconds, 'second');
  if (Math.abs(minutes) < 60) return rtf.format(minutes, 'minute');
  if (Math.abs(hours) < 24) return rtf.format(hours, 'hour');
  return rtf.format(days, 'day');
}

console.log(formatRelativeTime(new Date(Date.now() - 3600000))); // "1 godz. temu"

// Sam formatter: numeric: 'auto' zamienia liczby na słowa
const rtf = new Intl.RelativeTimeFormat('pl', { numeric: 'auto' });
console.log(rtf.format(-1, 'day'));  // "wczoraj"
console.log(rtf.format(-3, 'hour')); // "3 godziny temu"
console.log(rtf.format(2, 'day'));   // "pojutrze"
console.log(rtf.format(1, 'week'));  // "w przyszłym tygodniu"

Ręczna wersja zna tylko jeden język i sztywne końcówki, a Intl.RelativeTimeFormat sam odmienia słowa. Opcja numeric: 'auto' zamienia minus jeden dzień na "wczoraj", a plus dwa dni na "pojutrze".

Podsumowanie

Ray Arnold kończy szkolenie: "W systemach krytycznych jak Park Jurajski, precyzyjne zarządzanie czasem to kwestia życia i śmierci. Pamiętajcie:"

  1. Miesiące są od 0 - styczeń to 0, grudzień to 11
  2. Używajcie ISO 8601 do przechowywania dat ("2024-06-15T14:30:00Z")
  3. Intl.DateTimeFormat dla internacjonalizacji
  4. Unikajcie manipulacji stringami - używajcie metod Date
  5. Rozważcie biblioteki (date-fns, dayjs) dla złożonych operacji

Moja rada: zapisuj daty w UTC, a na czas lokalny zamieniaj je dopiero przy wyświetlaniu. Powstaje też nowe API Temporal, projektowane jako pełny następca Date - zanim po nie sięgniesz, sprawdź jego obsługę na MDN. W następnej lekcji zapiszesz dane w localStorage, skąd daty wracają jako zwykłe napisy.

Pamiętaj: zegar parku liczy miesiące od zera, a czas w milisekundach - pilnuj obu, a żaden dinozaur nie przegapi karmienia.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co zwraca Date.now() w JavaScript?

  2. 2. Jaka jest ważna pułapka przy pracy z miesiącami w obiekcie Date?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz harmonogram karmienia z obliczaniem następnego czasu karmienia i sprawdzaniem opóźnień.

  1. PytanieTworzenie obiektów Date
  2. PytanieMiesiące w obiekcie Date
  3. Zadanie z kodemPraktyka: Harmonogram karmienia dinozaurów

Przydatne artykuły