Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Obiekt Date i praca z czasem
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:00Zwróć 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. 1718451000000Tekst 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 UTCgetDate() 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()); // trueDzielenie 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:"
- Miesiące są od 0 - styczeń to 0, grudzień to 11
- Używajcie ISO 8601 do przechowywania dat ("2024-06-15T14:30:00Z")
- Intl.DateTimeFormat dla internacjonalizacji
- Unikajcie manipulacji stringami - używajcie metod Date
- 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. Co zwraca Date.now() w JavaScript?
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ń.