Przejdź do treści

Operacje na datach - Date.prototype - JS

W tym rozdziale dowiesz się...

W jaki sposób przeprowadzać operacje kalendarzowe na dacie i czasie?

Konstruktor obiektu daty - constructor

Gdzie jest zapisany konstruktor obiektu daty i czasu?

Date.prototype.constructor
Wartość:
Function - konstruktor obiektu

Zawiera konstruktor wbudowanego obiektu daty i czasu Date.

Przykład Date.prototype.constructor

Date.prototype.constructor === Date;   // true
new Date().constructor === Date;       // true
Date.prototype.constructor === Object; // false

Konwersja do tekstu - toString

Jak zamienić datę i czas na tekst, który można wyświetlić użytkownikowi?

Date.prototype.toString()
Wartość:
String - data i czas
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Zwraca datę i czas w postaci tekstowej. Uwzględnia aktualną strefę czasową. Format wyjściowy może się różnić w zależności od przeglądarki.

Dla daty x = new Date(0), poniższa równość jest prawdziwa:

Date.parse(x.toString()) == x.valueOf()

Przykład Date.prototype.toString

new Date(1410, 6, 15, 13, 30, 59).toString(); // np.: "Sun Jul 15 1410 13:30:59 GMT+0200"
 
Date.prototype.toString.call(null);           // TypeError
Date.prototype.toString.call(undefined);      // TypeError
Date.prototype.toString.call(0);              // TypeError
Date.prototype.toString.call("");             // TypeError
Date.prototype.toString.call("2000");         // TypeError
Date.prototype.toString.call({});             // TypeError

Konwersja daty do tekstu - toDateString

Jak zamienić datę na tekst, który można wyświetlić użytkownikowi?

Date.prototype.toDateString()
Wartość:
String - data
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Zwraca datę w postaci tekstowej. Uwzględnia aktualną strefę czasową. Format wyjściowy może się różnić w zależności od przeglądarki.

Aby wygenerować pełną datę i czas, użyj funkcji Date.prototype.toString.

Przykład Date.prototype.toDateString

new Date(1410, 6, 15).toDateString();        // np.: "Sun Jul 15 1410"
 
Date.prototype.toDateString.call(null);      // TypeError
Date.prototype.toDateString.call(undefined); // TypeError
Date.prototype.toDateString.call(0);         // TypeError
Date.prototype.toDateString.call("");        // TypeError
Date.prototype.toDateString.call("2000");    // TypeError
Date.prototype.toDateString.call({});        // TypeError

Konwersja czasu do tekstu - toTimeString

Jak zamienić czas na tekst, który można wyświetlić użytkownikowi?

Date.prototype.toTimeString()
Wartość:
String - czas
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Zwraca czas w postaci tekstowej. Uwzględnia aktualną strefę czasową. Format wyjściowy może się różnić w zależności od przeglądarki.

Aby wygenerować pełną datę i czas, użyj funkcji Date.prototype.toString.

Przykład Date.prototype.toTimeString

new Date(1410, 6, 15, 13, 30, 59).toTimeString(); // np.: "13:30:59 GMT+0200"
 
Date.prototype.toTimeString.call(null);           // TypeError
Date.prototype.toTimeString.call(undefined);      // TypeError
Date.prototype.toTimeString.call(0);              // TypeError
Date.prototype.toTimeString.call("");             // TypeError
Date.prototype.toTimeString.call("2000");         // TypeError
Date.prototype.toTimeString.call({});             // TypeError

Lokalizacja daty i czasu - toLocaleString

Jak zamienić datę i czas na tekst w formacie zgodnym z rodzimym językiem użytkownika?

Date.prototype.toLocaleString()
Wartość:
String - data i czas zapisane zgodnie z rodzimym językiem użytkownika
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Działa analogicznie jak Date.prototype.toString, ale zwraca datę i czas w postaci tekstu zapisanego w języku ustawionym domyślnie w systemie operacyjnym użytkownika. Uwzględnia aktualną strefę czasową.

Przykład Date.prototype.toLocaleString

new Date(1410, 6, 15, 13, 30, 59).toLocaleString(); // np.: "15 lipiec 1410 13:30:59"
 
Date.prototype.toLocaleString.call(null);           // TypeError
Date.prototype.toLocaleString.call(undefined);      // TypeError
Date.prototype.toLocaleString.call(0);              // TypeError
Date.prototype.toLocaleString.call("");             // TypeError
Date.prototype.toLocaleString.call("2000");         // TypeError
Date.prototype.toLocaleString.call({});             // TypeError

Lokalizacja daty - toLocaleDateString

Jak zamienić datę na tekst w formacie zgodnym z rodzimym językiem użytkownika?

Date.prototype.toLocaleDateString()
Wartość:
String - data zapisana zgodnie z rodzimym językiem użytkownika
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Działa analogicznie jak Date.prototype.toDateString, ale zwraca datę w postaci tekstu zapisanego w języku ustawionym domyślnie w systemie operacyjnym użytkownika. Uwzględnia aktualną strefę czasową.

Aby wygenerować pełną datę i czas w rodzimym języku użytkownika, użyj funkcji Date.prototype.toLocaleString.

Przykład Date.prototype.toLocaleDateString

new Date(1410, 6, 15).toLocaleDateString();        // np.: "15 lipiec 1410"
 
Date.prototype.toLocaleDateString.call(null);      // TypeError
Date.prototype.toLocaleDateString.call(undefined); // TypeError
Date.prototype.toLocaleDateString.call(0);         // TypeError
Date.prototype.toLocaleDateString.call("");        // TypeError
Date.prototype.toLocaleDateString.call("2000");    // TypeError
Date.prototype.toLocaleDateString.call({});        // TypeError

Lokalizacja czasu - toLocaleTimeString

Jak zamienić czas na tekst w formacie zgodnym z rodzimym językiem użytkownika?

Date.prototype.toLocaleTimeString()
Wartość:
String - czas zapisany zgodnie z rodzimym językiem użytkownika
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Działa analogicznie jak Date.prototype.toTimeString, ale zwraca czas w postaci tekstu zapisanego w języku ustawionym domyślnie w systemie operacyjnym użytkownika. Uwzględnia aktualną strefę czasową.

Aby wygenerować pełną datę i czas w rodzimym języku użytkownika, użyj funkcji Date.prototype.toLocaleString.

Przykład Date.prototype.toLocaleTimeString

new Date(1410, 6, 15, 13, 30, 59).toLocaleTimeString(); // np.: "13:30:59"
 
Date.prototype.toLocaleTimeString.call(null);           // TypeError
Date.prototype.toLocaleTimeString.call(undefined);      // TypeError
Date.prototype.toLocaleTimeString.call(0);              // TypeError
Date.prototype.toLocaleTimeString.call("");             // TypeError
Date.prototype.toLocaleTimeStringcall("2000");          // TypeError
Date.prototype.toLocaleTimeString.call({});             // TypeError

Pobieranie milisekund - valueOf

Jak pobrać liczbę milisekund, które upłynęły od północy 1 stycznia 1970 roku do podanej daty?

Date.prototype.valueOf()
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Zwraca liczbę milisekund, która upłynęła od północy 1 stycznia 1970 roku w strefie czasowej południka zerowego.

1 sekunda zawiera 1000 milisekund.

Działa tak samo jak Date.prototype.getTime.

Przykład Date.prototype.valueOf

new Date(2000, 0, 1).valueOf();         // 946681200000
 
Date.prototype.valueOf.call(null);      // TypeError
Date.prototype.valueOf.call(undefined); // TypeError
Date.prototype.valueOf.call(0);         // TypeError
Date.prototype.valueOf.call("");        // TypeError
Date.prototype.valueOf.call("2000");    // TypeError
Date.prototype.valueOf.call({});        // TypeError

Pobieranie czasu - getTime

Jak pobrać czas w postaci liczby milisekund, które upłynęły od północy 1 stycznia 1970 roku do podanej daty?

Date.prototype.getTime()
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Zwraca liczbę milisekund, która upłynęła od północy 1 stycznia 1970 roku w strefie czasowej południka zerowego.

1 sekunda zawiera 1000 milisekund.

Działa tak samo jak Date.prototype.valueOf.

Przykład Date.prototype.getTime

new Date(2000, 0, 1).getTime();         // 946681200000
 
Date.prototype.getTime.call(null);      // TypeError
Date.prototype.getTime.call(undefined); // TypeError
Date.prototype.getTime.call(0);         // TypeError
Date.prototype.getTime.call("");        // TypeError
Date.prototype.getTime.call("2000");    // TypeError
Date.prototype.getTime.call({});        // TypeError

Pobieranie roku - getFullYear

Jak pobrać rok z podanej daty?

Date.prototype.getFullYear()
Wartość:
Number - rok albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy rok z obiektu daty i czasu, przeliczony do lokalnej strefy czasowej. W tym przypadku lata są numerowane normalnie, tzn. 99 nie oznacza roku 1999. Ta funkcja może zwracać również wartości ujemne.

Przykład Date.prototype.getFullYear

new Date("1410-07-15T13:30+02:00").getFullYear(); // 1410
 
new Date(NaN).getFullYear();                      // NaN
 
Date.prototype.getFullYear.call(null);            // TypeError
Date.prototype.getFullYear.call(undefined);       // TypeError
Date.prototype.getFullYear.call(0);               // TypeError
Date.prototype.getFullYear.call("");              // TypeError
Date.prototype.getFullYear.call("2000");          // TypeError
Date.prototype.getFullYear.call({});              // TypeError

Pobieranie roku w UTC - getUTCFullYear

Jak pobrać rok z podanej daty w strefie czasowej południka zerowego (UTC)?

Date.prototype.getUTCFullYear()
Wartość:
Number - rok albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy rok z obiektu daty i czasu, przeliczony do strefy czasowej południka zerowego (UTC). W tym przypadku lata są numerowane normalnie, tzn. 99 nie oznacza roku 1999. Ta funkcja może zwracać również wartości ujemne.

Przykład Date.prototype.getUTCFullYear

new Date("1410-07-15T13:30+02:00").getUTCFullYear(); // 1410
 
new Date(NaN).getUTCFullYear();                      // NaN
 
Date.prototype.getUTCFullYear.call(null);            // TypeError
Date.prototype.getUTCFullYear.call(undefined);       // TypeError
Date.prototype.getUTCFullYear.call(0);               // TypeError
Date.prototype.getUTCFullYear.call("");              // TypeError
Date.prototype.getUTCFullYear.call("2000");          // TypeError
Date.prototype.getUTCFullYear.call({});              // TypeError

Pobieranie miesiąca - getMonth

Jak pobrać miesiąc z podanej daty

Date.prototype.getMonth()
Wartość:
Number - miesiąc (0...11) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy miesiąc z obiektu daty i czasu, przeliczony do lokalnej strefy czasowej.

Uczulam, że wartość 1 wcale nie oznacza stycznia, lecz luty. Natomiast 11 to grudzień.

Przykład Date.prototype.getMonth

new Date("1410-07-15T13:30+02:00").getMonth(); // 6 (lipiec)
 
new Date(NaN).getMonth();                      // NaN
 
Date.prototype.getMonth.call(null);            // TypeError
Date.prototype.getMonth.call(undefined);       // TypeError
Date.prototype.getMonth.call(0);               // TypeError
Date.prototype.getMonth.call("");              // TypeError
Date.prototype.getMonth.call("2000");          // TypeError
Date.prototype.getMonth.call({});              // TypeError

Pobieranie miesiąca w UTC - getUTCMonth

Jak pobrać miesiąc z podanej daty w strefie czasowej południka zerowego (UTC)?

Date.prototype.getUTCMonth()
Wartość:
Number - miesiąc (0...11) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy miesiąc z obiektu daty i czasu, przeliczony do strefy czasowej południka zerowego (UTC).

Uczulam, że wartość 1 wcale nie oznacza stycznia, lecz luty. Natomiast 11 to grudzień.

Przykład Date.prototype.getUTCMonth

new Date("1410-07-15T13:30+02:00").getUTCMonth(); // 6 (lipiec)
 
new Date(NaN).getUTCMonth();                      // NaN
 
Date.prototype.getUTCMonth.call(null);            // TypeError
Date.prototype.getUTCMonth.call(undefined);       // TypeError
Date.prototype.getUTCMonth.call(0);               // TypeError
Date.prototype.getUTCMonth.call("");              // TypeError
Date.prototype.getUTCMonth.call("2000");          // TypeError
Date.prototype.getUTCMonth.call({});              // TypeError

Pobieranie dnia miesiąca - getDate

Jak pobrać dzień miesiąca z podanej daty?

Date.prototype.getDate()
Wartość:
Number - dzień miesiąca (1...31) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy dzień miesiąca z obiektu daty i czasu, przeliczony do lokalnej strefy czasowej.

Aby pobrać dzień tygodnia, użyj funkcji Date.prototype.getDay.

Przykład Date.prototype.getDate

new Date("1410-07-15T13:30+02:00").getDate(); // 15
 
new Date(NaN).getDate();                      // NaN
 
Date.prototype.getDate.call(null);            // TypeError
Date.prototype.getDate.call(undefined);       // TypeError
Date.prototype.getDate.call(0);               // TypeError
Date.prototype.getDate.call("");              // TypeError
Date.prototype.getDate.call("2000");          // TypeError
Date.prototype.getDate.call({});              // TypeError

Pobieranie dnia miesiąca w UTC - getUTCDate

Jak pobrać dzień miesiąca z podanej daty w strefie czasowej południka zerowego (UTC)?

Date.prototype.getUTCDate()
Wartość:
Number - dzień miesiąca (1...31) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy dzień miesiąca z obiektu daty i czasu, przeliczony do strefy czasowej południka zerowego (UTC).

Aby pobrać dzień tygodnia w strefie UTC, użyj funkcji Date.prototype.getUTCDay.

Przykład Date.prototype.getUTCDate

new Date("1410-07-15T13:30+02:00").getUTCDate(); // 15
 
new Date(NaN).getUTCDate();                      // NaN
 
Date.prototype.getUTCDate.call(null);            // TypeError
Date.prototype.getUTCDate.call(undefined);       // TypeError
Date.prototype.getUTCDate.call(0);               // TypeError
Date.prototype.getUTCDate.call("");              // TypeError
Date.prototype.getUTCDate.call("2000");          // TypeError
Date.prototype.getUTCDate.call({});              // TypeError

Pobieranie dnia tygodnia - getDay

Jak pobrać dzień tygodnia z podanej daty?

Date.prototype.getDay()
Wartość:
Number - dzień tygodnia z zakresu od 0 (niedziela) do 6 (sobota) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy dzień tygodnia z obiektu daty i czasu, przeliczony do lokalnej strefy czasowej.

Podkreślam, że zliczanie dni tygodnia rozpoczyna się tutaj nie od poniedziałku, lecz od niedzieli (która ma numer 0).

Aby pobrać dzień miesiąca, użyj funkcji Date.prototype.getDate.

Przykład Date.prototype.getDay

new Date("1410-07-15T13:30+02:00").getDay(); // 0 (niedziela)
 
new Date(NaN).getDay();                      // NaN
 
Date.prototype.getDay.call(null);            // TypeError
Date.prototype.getDay.call(undefined);       // TypeError
Date.prototype.getDay.call(0);               // TypeError
Date.prototype.getDay.call("");              // TypeError
Date.prototype.getDay.call("2000");          // TypeError
Date.prototype.getDay.call({});              // TypeError

Pobieranie dnia tygodnia w UTC - getUTCDay

Jak pobrać dzień tygodnia z podanej daty w strefie czasowej UTC?

Date.prototype.getUTCDay()
Wartość:
Number - dzień tygodnia z zakresu od 0 (niedziela) do 6 (sobota) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbowy dzień tygodnia z obiektu daty i czasu, przeliczony do strefy czasowej południka zerowego (UTC).

Podkreślam, że zliczanie dni tygodnia rozpoczyna się tutaj nie od poniedziałku, lecz od niedzieli (która ma numer 0).

Aby pobrać dzień miesiąca w strefie UTC, użyj funkcji Date.prototype.getUTCDate.

Przykład Date.prototype.getUTCDay

new Date("1410-07-15T13:30+02:00").getUTCDay(); // 0 (niedziela)
 
new Date(NaN).getUTCDay();                      // NaN
 
Date.prototype.getUTCDay.call(null);            // TypeError
Date.prototype.getUTCDay.call(undefined);       // TypeError
Date.prototype.getUTCDay.call(0);               // TypeError
Date.prototype.getUTCDay.call("");              // TypeError
Date.prototype.getUTCDay.call("2000");          // TypeError
Date.prototype.getUTCDay.call({});              // TypeError

Pobieranie godziny - getHours

Jak pobrać godzinę z podanej daty?

Date.prototype.getHours()
Wartość:
Number - godzina (0...23) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową godzinę z obiektu daty i czasu, przeliczoną do lokalnej strefy czasowej.

Przykład Date.prototype.getHours

new Date("1410-07-15T13:30+02:00").getHours(); // 13
 
new Date(NaN).getHours();                      // NaN
 
Date.prototype.getHours.call(null);            // TypeError
Date.prototype.getHours.call(undefined);       // TypeError
Date.prototype.getHours.call(0);               // TypeError
Date.prototype.getHours.call("");              // TypeError
Date.prototype.getHours.call("2000");          // TypeError
Date.prototype.getHours.call({});              // TypeError

Pobieranie godziny w UTC - getUTCHours

Jak pobrać godzinę z podanej daty w strefie czasowej południka zerowego (UTC)?

Date.prototype.getUTCHours()
Wartość:
Number - godzina (0...23) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową godzinę z obiektu daty i czasu, przeliczoną do strefy czasowej południka zerowego (UTC).

Przykład Date.prototype.getUTCHours

new Date("1410-07-15T13:30+02:00").getUTCHours(); // 11
 
new Date(NaN).getUTCHours();                      // NaN
 
Date.prototype.getUTCHours.call(null);            // TypeError
Date.prototype.getUTCHours.call(undefined);       // TypeError
Date.prototype.getUTCHours.call(0);               // TypeError
Date.prototype.getUTCHours.call("");              // TypeError
Date.prototype.getUTCHours.call("2000");          // TypeError
Date.prototype.getUTCHours.call({});              // TypeError

Pobieranie minut - getMinutes

Jak pobrać minutę z podanej daty?

Date.prototype.getMinutes()
Wartość:
Number - minuta (0...59) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową minutę z obiektu daty i czasu, przeliczoną do lokalnej strefy czasowej.

Przykład Date.prototype.getMinutes

new Date("1410-07-15T13:30+02:00").getMinutes(); // 30
 
new Date(NaN).getMinutes();                      // NaN
 
Date.prototype.getMinutes.call(null);            // TypeError
Date.prototype.getMinutes.call(undefined);       // TypeError
Date.prototype.getMinutes.call(0);               // TypeError
Date.prototype.getMinutes.call("");              // TypeError
Date.prototype.getMinutes.call("2000");          // TypeError
Date.prototype.getMinutes.call({});              // TypeError

Pobieranie minut w UTC - getUTCMinutes

Jak pobrać minutę z podanej daty w strefie czasowej południka zerowego (UTC)?

Date.prototype.getUTCMinutes()
Wartość:
Number - minuta (0...59) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową minutę z obiektu daty i czasu, przeliczoną do strefy czasowej południka zerowego (UTC).

Przykład Date.prototype.getUTCMinutes

new Date("1410-07-15T13:30+02:00").getUTCMinutes(); // 30
 
new Date(NaN).getUTCMinutes();                      // NaN
 
Date.prototype.getUTCMinutes.call(null);            // TypeError
Date.prototype.getUTCMinutes.call(undefined);       // TypeError
Date.prototype.getUTCMinutes.call(0);               // TypeError
Date.prototype.getUTCMinutes.call("");              // TypeError
Date.prototype.getUTCMinutes.call("2000");          // TypeError
Date.prototype.getUTCMinutes.call({});              // TypeError

Pobieranie sekund - getSeconds

Jak pobrać sekundę z podanej daty?

Date.prototype.getSeconds()
Wartość:
Number - sekunda (0...59) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową sekundę z obiektu daty i czasu, przeliczoną do lokalnej strefy czasowej.

Przykład Date.prototype.getSeconds

new Date("1410-07-15T13:30:59+02:00").getSeconds(); // 59
 
new Date(NaN).getSeconds();                         // NaN
 
Date.prototype.getSeconds.call(null);               // TypeError
Date.prototype.getSeconds.call(undefined);          // TypeError
Date.prototype.getSeconds.call(0);                  // TypeError
Date.prototype.getSeconds.call("");                 // TypeError
Date.prototype.getSeconds.call("2000");             // TypeError
Date.prototype.getSeconds.call({});                 // TypeError

Pobieranie sekund w UTC - getUTCSeconds

Jak pobrać sekundę z podanej daty w strefie czasowej południka zerowego (UTC)?

Date.prototype.getUTCSeconds()
Wartość:
Number - sekunda (0...59) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową sekundę z obiektu daty i czasu, przeliczoną do strefy czasowej południka zerowego (UTC).

Przykład Date.prototype.getUTCSeconds

new Date("1410-07-15T13:30:59+02:00").getUTCSeconds(); // 59
 
new Date(NaN).getUTCSeconds();                         // NaN
 
Date.prototype.getUTCSeconds.call(null);               // TypeError
Date.prototype.getUTCSeconds.call(undefined);          // TypeError
Date.prototype.getUTCSeconds.call(0);                  // TypeError
Date.prototype.getUTCSeconds.call("");                 // TypeError
Date.prototype.getUTCSeconds.call("2000");             // TypeError
Date.prototype.getUTCSeconds.call({});                 // TypeError

Pobieranie milisekund - getMilliseconds

Jak pobrać milisekundę z podanej daty?

Date.prototype.getMilliseconds()
Wartość:
Number - milisekunda (0...999) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową milisekundę z obiektu daty i czasu, przeliczoną do lokalnej strefy czasowej.

1 sekunda zawiera 1000 milisekund.

Przykład Date.prototype.getMilliseconds

new Date("1410-07-15T13:30:59.500+02:00").getMilliseconds(); // 500
 
new Date(NaN).getMilliseconds();                             // NaN
 
Date.prototype.getMilliseconds.call(null);                   // TypeError
Date.prototype.getMilliseconds.call(undefined);              // TypeError
Date.prototype.getMilliseconds.call(0);                      // TypeError
Date.prototype.getMilliseconds.call("");                     // TypeError
Date.prototype.getMilliseconds.call("2000");                 // TypeError
Date.prototype.getMilliseconds.call({});                     // TypeError

Pobieranie milisekund w UTC - getUTCMilliseconds

Jak pobrać milisekundę z podanej daty w strefie czasowej południka zerowego (UTC)?

Date.prototype.getUTCMilliseconds()
Wartość:
Number - milisekunda (0...999) albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Pobiera liczbową milisekundę z obiektu daty i czasu, przeliczoną do strefy czasowej południka zerowego (UTC).

1 sekunda zawiera 1000 milisekund.

Przykład Date.prototype.getUTCMilliseconds

new Date("1410-07-15T13:30:59.500+02:00").getUTCMilliseconds(); // 500
 
new Date(NaN).getUTCMilliseconds();                             // NaN
 
Date.prototype.getUTCMilliseconds.call(null);                   // TypeError
Date.prototype.getUTCMilliseconds.call(undefined);              // TypeError
Date.prototype.getUTCMilliseconds.call(0);                      // TypeError
Date.prototype.getUTCMilliseconds.call("");                     // TypeError
Date.prototype.getUTCMilliseconds.call("2000");                 // TypeError
Date.prototype.getUTCMilliseconds.call({});                     // TypeError

Pobieranie przesunięcia strefy czasowej - getTimezoneOffset

Jak pobrać przesunięcie strefy czasowej dla podanej daty?

Date.prototype.getTimezoneOffset()
Wartość:
Number - różnica minut pomiędzy UTC a czasem lokalnym albo NaN (gdy bieżący obiekt nie przechowuje poprawnej daty i czasu)
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Sprawdza, jaka była/będzie określonego dnia różnica minut pomiędzy strefą czasową południka zerowego a czasem lokalnym. Jest to liczba przeciwna do przesunięcia strefy czasowej, podawanego przy ustawianiu czasu.

Przykład Date.prototype.getTimezoneOffset

new Date("1410-07-15T13:30+02:00").getTimezoneOffset(); // -120
 
new Date(NaN).getTimezoneOffset();                      // NaN
 
Date.prototype.getTimezoneOffset.call(null);            // TypeError
Date.prototype.getTimezoneOffset.call(undefined);       // TypeError
Date.prototype.getTimezoneOffset.call(0);               // TypeError
Date.prototype.getTimezoneOffset.call("");              // TypeError
Date.prototype.getTimezoneOffset.call("2000");          // TypeError
Date.prototype.getTimezoneOffset.call({});              // TypeError

Ustawianie daty i czasu - setTime

Jak ustawić datę i czas poprzez podanie liczby milisekund, które upłynęły od północy 1 stycznia 1970 roku?

Date.prototype.setTime(time)
Parametry:
Number time - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wartość:
Number - ustawiona wartość time
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia pełną datę i czas poprzez określenie liczby milisekund, która upłynęła od północy 1 stycznia 1970 roku w strefie czasowej południka zerowego.

1 sekunda zawiera 1000 milisekund.

Aby pobrać aktualną wartość, użyj funkcji Date.prototype.getTime.

Przykład Date.prototype.setTime

var x = new Date(2000, 0, 1);
x.setTime(x.getTime() + 86400000);         // 946767600000
x;                                         // new Date(2000, 0, 2)
 
Date.prototype.setTime.call(null, 0);      // TypeError
Date.prototype.setTime.call(undefined, 0); // TypeError
Date.prototype.setTime.call(0, 0);         // TypeError
Date.prototype.setTime.call("", 0);        // TypeError
Date.prototype.setTime.call("2000", 0);    // TypeError
Date.prototype.setTime.call({}, 0);        // TypeError

Ustawianie milisekund - setMilliseconds

Jak zmienić milisekundę w podanej dacie?

Date.prototype.setMilliseconds(ms)
Parametry:
Number ms - milisekunda z zakresu 0...999
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową milisekundę w obiekcie daty i czasu, określoną w lokalnej strefy czasowej. Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

1 sekunda zawiera 1000 milisekund.

Aby pobrać aktualną wartość, użyj funkcji Date.prototype.getMilliseconds.

Przykład Date.prototype.setMilliseconds

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setMilliseconds(500);                            // -17655020940500
x;                                                 // new Date("1410-07-15T13:30:59.500+02:00")
x.setMilliseconds(1250);                           // -17655020939750
x;                                                 // new Date("1410-07-15T13:31:00.250+02:00")
x.setMilliseconds(-500);                           // -17655020940500
x;                                                 // new Date("1410-07-15T13:30:59.500+02:00")
 
Date.prototype.setMilliseconds.call(null, 0);      // TypeError
Date.prototype.setMilliseconds.call(undefined, 0); // TypeError
Date.prototype.setMilliseconds.call(0, 0);         // TypeError
Date.prototype.setMilliseconds.call("", 0);        // TypeError
Date.prototype.setMilliseconds.call("2000", 0);    // TypeError
Date.prototype.setMilliseconds.call({}, 0);        // TypeError

Ustawianie milisekund w UTC - setUTCMilliseconds

Jak zmienić milisekundę w podanej dacie, określoną w strefie czasowej południka zerowego (UTC)?

Date.prototype.setUTCMilliseconds(ms)
Parametry:
Number ms - milisekunda z zakresu 0...999
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową milisekundę w obiekcie daty i czasu, określoną w strefie czasowej południka zerowego (UTC). Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

1 sekunda zawiera 1000 milisekund.

Aby pobrać aktualną wartość, użyj funkcji Date.prototype.getUTCMilliseconds.

Przykład Date.prototype.setUTCMilliseconds

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setUTCMilliseconds(500);                            // -17655020940500
x;                                                    // new Date("1410-07-15T13:30:59.500+02:00")
x.setUTCMilliseconds(1250);                           // -17655020939750
x;                                                    // new Date("1410-07-15T13:31:00.250+02:00")
x.setUTCMilliseconds(-500);                           // -17655020940500
x;                                                    // new Date("1410-07-15T13:30:59.500+02:00")
 
Date.prototype.setUTCMilliseconds.call(null, 0);      // TypeError
Date.prototype.setUTCMilliseconds.call(undefined, 0); // TypeError
Date.prototype.setUTCMilliseconds.call(0, 0);         // TypeError
Date.prototype.setUTCMilliseconds.call("", 0);        // TypeError
Date.prototype.setUTCMilliseconds.call("2000", 0);    // TypeError
Date.prototype.setUTCMilliseconds.call({}, 0);        // TypeError

Ustawianie sekund - setSeconds

Jak zmienić sekundę w podanej dacie?

Date.prototype.setSeconds(sec)
Date.prototype.setSeconds(sec, ms)
Parametry:
Number sec - sekunda z zakresu 0...59
Number ms - milisekunda z zakresu 0...999 (domyślnie: wartość Date.prototype.getMilliseconds())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową sekundę oraz ewentualnie milisekundę w obiekcie daty i czasu, określoną w lokalnej strefie czasowej. Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

Przykład Date.prototype.setSeconds

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setSeconds(0, 500);                         // -17655020999500
x;                                            // new Date("1410-07-15T13:30:00.500+02:00")
x.setSeconds(90);                             // -17655020909500
x;                                            // new Date("1410-07-15T13:31:30.500+02:00")
x.setSeconds(-30);                            // -17655020969500
x;                                            // new Date("1410-07-15T13:30:30.500+02:00")
 
Date.prototype.setSeconds.call(null, 0);      // TypeError
Date.prototype.setSeconds.call(undefined, 0); // TypeError
Date.prototype.setSeconds.call(0, 0);         // TypeError
Date.prototype.setSeconds.call("", 0);        // TypeError
Date.prototype.setSeconds.call("2000", 0);    // TypeError
Date.prototype.setSeconds.call({}, 0);        // TypeError

Ustawianie sekund w UTC - setUTCSeconds

Jak zmienić sekundę w podanej dacie, określoną w strefie czasowej południka zerowego (UTC)?

Date.prototype.setUTCSeconds(sec)
Date.prototype.setUTCSeconds(sec, ms)
Parametry:
Number sec - sekunda z zakresu 0...59
Number ms - milisekunda z zakresu 0...999 (domyślnie: wartość Date.prototype.getUTCMilliseconds())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową sekundę oraz ewentualnie milisekundę w obiekcie daty i czasu, określoną w strefie czasowej południka zerowego (UTC). Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

Przykład Date.prototype.setUTCSeconds

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setUTCSeconds(0, 500);                         // -17655020999500
x;                                               // new Date("1410-07-15T13:30:00.500+02:00")
x.setUTCSeconds(90);                             // -17655020909500
x;                                               // new Date("1410-07-15T13:31:30.500+02:00")
x.setUTCSeconds(-30);                            // -17655020969500
x;                                               // new Date("1410-07-15T13:30:30.500+02:00")
 
Date.prototype.setUTCSeconds.call(null, 0);      // TypeError
Date.prototype.setUTCSeconds.call(undefined, 0); // TypeError
Date.prototype.setUTCSeconds.call(0, 0);         // TypeError
Date.prototype.setUTCSeconds.call("", 0);        // TypeError
Date.prototype.setUTCSeconds.call("2000", 0);    // TypeError
Date.prototype.setUTCSeconds.call({}, 0);        // TypeError

Ustawianie minut - setMinutes

Jak zmienić minutę w podanej dacie?

Date.prototype.setMinutes(min)
Date.prototype.setMinutes(min, sec)
Date.prototype.setMinutes(min, sec, ms)
Parametry:
Number min - minuta z zakresu 0...59
Number sec - sekunda z zakresu 0...59 (domyślnie: wartość Date.prototype.getSeconds())
Number ms - milisekunda z zakresu 0...999 (domyślnie: wartość Date.prototype.getMilliseconds())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową minutę oraz ewentualnie sekundę i milisekundę w obiekcie daty i czasu, określoną w lokalnej strefie czasowej. Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

Przykład Date.prototype.setMinutes

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setMinutes(15, 0, 500);                     // -17655021899500
x;                                            // new Date("1410-07-15T13:15:00.500+02:00")
x.setMinutes(90);                             // -17655017399500
x;                                            // new Date("1410-07-15T14:30:00.500+02:00")
x.setMinutes(-30);                            // -17655020999500
x;                                            // new Date("1410-07-15T13:30:00.500+02:00")
 
Date.prototype.setMinutes.call(null, 0);      // TypeError
Date.prototype.setMinutes.call(undefined, 0); // TypeError
Date.prototype.setMinutes.call(0, 0);         // TypeError
Date.prototype.setMinutes.call("", 0);        // TypeError
Date.prototype.setMinutes.call("2000", 0);    // TypeError
Date.prototype.setMinutes.call({}, 0);        // TypeError

Ustawianie minut w UTC - setUTCMinutes

Jak zmienić minutę w podanej dacie, określoną w strefie czasowej południka zerowego (UTC)?

Date.prototype.setUTCMinutes(min)
Date.prototype.setUTCMinutes(min, sec)
Date.prototype.setUTCMinutes(min, sec, ms)
Parametry:
Number min - minuta z zakresu 0...59
Number sec - sekunda z zakresu 0...59 (domyślnie: wartość Date.prototype.getUTCSeconds())
Number ms - milisekunda z zakresu 0...999 (domyślnie: wartość Date.prototype.getUTCMilliseconds())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową minutę oraz ewentualnie sekundę i milisekundę w obiekcie daty i czasu, określoną w strefie czasowej południka zerowego (UTC). Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

Przykład Date.prototype.setUTCMinutes

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setUTCMinutes(15, 0, 500);                     // -17655021899500
x;                                               // new Date("1410-07-15T13:15:00.500+02:00")
x.setUTCMinutes(90);                             // -17655017399500
x;                                               // new Date("1410-07-15T14:30:00.500+02:00")
x.setUTCMinutes(-30);                            // -17655020999500
x;                                               // new Date("1410-07-15T13:30:00.500+02:00")
 
Date.prototype.setUTCMinutes.call(null, 0);      // TypeError
Date.prototype.setUTCMinutes.call(undefined, 0); // TypeError
Date.prototype.setUTCMinutes.call(0, 0);         // TypeError
Date.prototype.setUTCMinutes.call("", 0);        // TypeError
Date.prototype.setUTCMinutes.call("2000", 0);    // TypeError
Date.prototype.setUTCMinutes.call({}, 0);        // TypeError

Ustawianie godzin - setHours

Jak zmienić godzinę w podanej dacie?

Date.prototype.setHours(hour)
Date.prototype.setHours(hour, min)
Date.prototype.setHours(hour, min, sec)
Date.prototype.setHours(hour, min, sec, ms)
Parametry:
Number hour - godzina z zakresu 0...23
Number min - minuta z zakresu 0...59 (domyślnie: wartość Date.prototype.getMinutes())
Number sec - sekunda z zakresu 0...59 (domyślnie: wartość Date.prototype.getSeconds())
Number ms - milisekunda z zakresu 0...999 (domyślnie: wartość Date.prototype.getMilliseconds())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową godzinę oraz ewentualnie minutę, sekundę i milisekundę w obiekcie daty i czasu, określoną w lokalnej strefie czasowej. Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę. Wartość 24, podana jako hour, oznacza północ następnego dnia, 25 - godzina pierwsza w nocy następnego dnia itd.

Przykład Date.prototype.setHours

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setHours(12, 15, 0, 500);                 // -17655025499500
x;                                          // new Date("1410-07-15T12:15:00.500+02:00")
x.setHours(25);                             // -17654978699500
x;                                          // new Date("1410-07-16T01:15:00.500+02:00")
x.setHours(-2);                             // -17654989499500
x;                                          // new Date("1410-07-15T22:15:00.500+02:00")
 
Date.prototype.setHours.call(null, 0);      // TypeError
Date.prototype.setHours.call(undefined, 0); // TypeError
Date.prototype.setHours.call(0, 0);         // TypeError
Date.prototype.setHours.call("", 0);        // TypeError
Date.prototype.setHours.call("2000", 0);    // TypeError
Date.prototype.setHours.call({}, 0);        // TypeError

Ustawianie godzin w UTC - setUTCHours

Jak zmienić godzinę w podanej dacie, określoną w strefie czasowej południka zerowego (UTC)?

Date.prototype.setUTCHours(hour)
Date.prototype.setUTCHours(hour, min)
Date.prototype.setUTCHours(hour, min, sec)
Date.prototype.setUTCHours(hour, min, sec, ms)
Parametry:
Number hour - godzina z zakresu 0...23
Number min - minuta z zakresu 0...59 (domyślnie: wartość Date.prototype.getUTCMinutes())
Number sec - sekunda z zakresu 0...59 (domyślnie: wartość Date.prototype.getUTCSeconds())
Number ms - milisekunda z zakresu 0...999 (domyślnie: wartość Date.prototype.getUTCMilliseconds())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbową godzinę oraz ewentualnie minutę, sekundę i milisekundę w obiekcie daty i czasu, określoną w strefie czasowej południka zerowego (UTC). Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę. Wartość 24, podana jako hour, oznacza północ następnego dnia, 25 - godzina pierwsza w nocy następnego dnia itd.

Przykład Date.prototype.setUTCHours

var x = new Date("1410-07-15T13:30:59.000+02:00");
x.setUTCHours(12, 15, 0, 500);                 // -17655018299500
x;                                             // new Date("1410-07-15T14:15:00.500+02:00")
x.setUTCHours(25);                             // -17654971499500
x;                                             // new Date("1410-07-16T03:15:00.500+02:00")
x.setUTCHours(-2);                             // -17654982299500
x;                                             // new Date("1410-07-16T00:15:00.500+02:00")
 
Date.prototype.setUTCHours.call(null, 0);      // TypeError
Date.prototype.setUTCHours.call(undefined, 0); // TypeError
Date.prototype.setUTCHours.call(0, 0);         // TypeError
Date.prototype.setUTCHours.call("", 0);        // TypeError
Date.prototype.setUTCHours.call("2000", 0);    // TypeError
Date.prototype.setUTCHours.call({}, 0);        // TypeError

Ustawianie dnia miesiąca - setDate

Jak zmienić dzień miesiąca w podanej dacie?

Date.prototype.setDate(date)
Parametry:
Number date - dzień miesiąca z zakresu 0...31
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbowy dzień miesiąca w obiekcie daty i czasu, określony w lokalnej strefie czasowej. Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę, uwzględniając nawet lata przestępne.

Przykład Date.prototype.setDate

var x = new Date("1410-07-15T00:00:00.000+02:00");
x.setDate(16);                             // -17654983200000
x;                                         // new Date("1410-07-16T00:00:00.000+02:00")
x.setDate(32);                             // -17653600800000
x;                                         // new Date("1410-08-01T00:00:00.000+02:00")
x.setDate(-2);                             // -17653860000000
x;                                         // new Date("1410-07-29T00:00:00.000+02:00")
 
Date.prototype.setDate.call(null, 0);      // TypeError
Date.prototype.setDate.call(undefined, 0); // TypeError
Date.prototype.setDate.call(0, 0);         // TypeError
Date.prototype.setDate.call("", 0);        // TypeError
Date.prototype.setDate.call("2000", 0);    // TypeError
Date.prototype.setDate.call({}, 0);        // TypeError

Ustawianie dnia miesiąca w UTC - setUTCDate

Jak zmienić dzień miesiąca w podanej dacie, określony w strefie czasowej południka zerowego (UTC)?

Date.prototype.setUTCDate(date)
Parametry:
Number date - dzień miesiąca z zakresu 0...31
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbowy dzień miesiąca w obiekcie daty i czasu, określony w strefie czasowej południka zerowego (UTC). Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę, uwzględniając nawet lata przestępne.

Przykład Date.prototype.setUTCDate

var x = new Date("1410-07-15T00:00:00.000+02:00");
x.setUTCDate(16);                             // -17654896800000
x;                                            // new Date("1410-07-17T00:00:00.000+02:00")
x.setUTCDate(32);                             // -17653600800000
x;                                            // new Date("1410-08-02T00:00:00.000+02:00")
x.setUTCDate(-2);                             // -17653773600000
x;                                            // new Date("1410-07-30T00:00:00.000+02:00")
 
Date.prototype.setUTCDate.call(null, 0);      // TypeError
Date.prototype.setUTCDate.call(undefined, 0); // TypeError
Date.prototype.setUTCDate.call(0, 0);         // TypeError
Date.prototype.setUTCDate.call("", 0);        // TypeError
Date.prototype.setUTCDate.call("2000", 0);    // TypeError
Date.prototype.setUTCDate.call({}, 0);        // TypeError

Ustawianie miesiąca - setMonth

Jak zmienić miesiąc w podanej dacie?

Date.prototype.setMonth(month)
Date.prototype.setMonth(month, date)
Parametry:
Number month - miesiąc z zakresu 0...11
Number date - dzień miesiąca z zakresu 0...31 (domyślnie: wartość Date.prototype.getDate())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbowy miesiąc oraz ewentualnie dzień miesiąca w obiekcie daty i czasu, określony w lokalnej strefie czasowej. Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

Uczulam, że wartość 1, podana jako month, wcale nie oznacza stycznia, lecz luty. Natomiast 11 to grudzień.

Przykład Date.prototype.setMonth

var x = new Date("1410-07-15T00:00:00.000+02:00");
x.setMonth(7, 3);                           // -17653428000000
x;                                          // new Date("1410-08-03T00:00:00.000+02:00")
x.setMonth(12);                             // -17640205200000
x;                                          // new Date("1411-01-03T00:00:00.000+01:00")
x.setMonth(-1);                             // -17642883600000
x;                                          // new Date("1410-12-03T00:00:00.000+01:00")
 
Date.prototype.setMonth.call(null, 0);      // TypeError
Date.prototype.setMonth.call(undefined, 0); // TypeError
Date.prototype.setMonth.call(0, 0);         // TypeError
Date.prototype.setMonth.call("", 0);        // TypeError
Date.prototype.setMonth.call("2000", 0);    // TypeError
Date.prototype.setMonth.call({}, 0);        // TypeError

Ustawianie miesiąca w UTC - setUTCMonth

Jak zmienić miesiąc w podanej dacie, określony w strefie czasowej południka zerowego (UTC)?

Date.prototype.setUTCMonth(month)
Date.prototype.setUTCMonth(month, date)
Parametry:
Number month - miesiąc z zakresu 0...11
Number date - dzień miesiąca z zakresu 0...31 (domyślnie: wartość Date.prototype.getUTCDate())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbowy miesiąc oraz ewentualnie dzień miesiąca w obiekcie daty i czasu, określony w strefie czasowej południka zerowego (UTC). Możliwe jest również podanie wartości spoza przewidzianego zakresu - w tym ujemnej. Wtedy funkcja sama przeliczy prawidłową datę.

Uczulam, że wartość 1, podana jako month, wcale nie oznacza stycznia, lecz luty. Natomiast 11 to grudzień.

Przykład Date.prototype.setUTCMonth

var x = new Date("1410-07-15T00:00:00.000+02:00");
x.setUTCMonth(7, 3);                           // -17653341600000
x;                                             // new Date("1410-08-04T00:00:00.000+02:00")
x.setUTCMonth(12);                             // 17640122400000
x;                                             // new Date("1411-01-03T23:00:00.000+01:00")
x.setUTCMonth(-1);                             // -17642800800000
x;                                             // new Date("1410-12-03T23:00:00.000+01:00")
 
Date.prototype.setUTCMonth.call(null, 0);      // TypeError
Date.prototype.setUTCMonth.call(undefined, 0); // TypeError
Date.prototype.setUTCMonth.call(0, 0);         // TypeError
Date.prototype.setUTCMonth.call("", 0);        // TypeError
Date.prototype.setUTCMonth.call("2000", 0);    // TypeError
Date.prototype.setUTCMonth.call({}, 0);        // TypeError

Ustawianie roku - setFullYear

Jak zmienić rok w podanej dacie?

Date.prototype.setFullYear(year)
Date.prototype.setFullYear(year, month)
Date.prototype.setFullYear(year, month, date)
Parametry:
Number year - rok
Number month - miesiąc z zakresu 0...11 (domyślnie: wartość Date.prototype.getMonth())
Number date - dzień miesiąca z zakresu 0...31 (domyślnie: wartość Date.prototype.getDate())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbowy rok oraz ewentualnie miesiąc i dzień miesiąca w obiekcie daty i czasu, określony w lokalnej strefie czasowej. Możliwe jest również podawanie wartości ujemnych.

Przykład Date.prototype.setFullYear

var x = new Date("1410-07-15T00:00:00.000+02:00");
x.setFullYear(2000, 0, 1);                     // 946681200000
x;                                             // new Date("2000-01-01T00:00:00.000+01:00")
 
Date.prototype.setFullYear.call(null, 0);      // TypeError
Date.prototype.setFullYear.call(undefined, 0); // TypeError
Date.prototype.setFullYear.call(0, 0);         // TypeError
Date.prototype.setFullYear.call("", 0);        // TypeError
Date.prototype.setFullYear.call("2000", 0);    // TypeError
Date.prototype.setFullYear.call({}, 0);        // TypeError

Ustawianie roku w UTC - setUTCFullYear

Jak zmienić rok w podanej dacie, określony w strefie czasowej południka zerowego (UTC)?

Date.prototype.setUTCFullYear(year)
Date.prototype.setUTCFullYear(year, month)
Date.prototype.setUTCFullYear(year, month, date)
Parametry:
Number year - rok
Number month - miesiąc z zakresu 0...11 (domyślnie: wartość Date.prototype.getMonth())
Number date - dzień miesiąca z zakresu 0...31 (domyślnie: wartość Date.prototype.getDate())
Wartość:
Number - liczba milisekund od północy 1 stycznia 1970 w strefie czasowej południka zerowego
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Ustawia liczbowy rok oraz ewentualnie miesiąc i dzień miesiąca w obiekcie daty i czasu, określony w strefie czasowej południka zerowego (UTC). Możliwe jest również podawanie wartości ujemnych.

Przykład Date.prototype.setUTCFullYear

var x = new Date("1410-07-15T00:00:00.000+02:00");
x.setUTCFullYear(2000, 0, 1);                     // 946764000000
x;                                                // new Date("2000-01-01T23:00:00.000+01:00")
 
Date.prototype.setUTCFullYear.call(null, 0);      // TypeError
Date.prototype.setUTCFullYear.call(undefined, 0); // TypeError
Date.prototype.setUTCFullYear.call(0, 0);         // TypeError
Date.prototype.setUTCFullYear.call("", 0);        // TypeError
Date.prototype.setUTCFullYear.call("2000", 0);    // TypeError
Date.prototype.setUTCFullYear.call({}, 0);        // TypeError

Konwersja do formatu UTC - toUTCString

Jak zamienić datę i czas na tekst zapisany w formacie UTC (GMT)?

Date.prototype.toString()
Wartość:
String - data i czas
Wyjątki:
TypeError - bieżący obiekt nie jest typu daty i czasu

Działa analogicznie jak Date.prototype.toString, ale zwraca datę i czas zawsze w strefie czasowej południka zerowego (UTC).

Przykład Date.prototype.toUTCString

new Date(1410, 6, 15, 13, 30, 59).toUTCString(); // np.: "Sun, 15 Jul 1410 11:30:59 GMT"
 
Date.prototype.toUTCString.call(null);           // TypeError
Date.prototype.toUTCString.call(undefined);      // TypeError
Date.prototype.toUTCString.call(0);              // TypeError
Date.prototype.toUTCString.call("");             // TypeError
Date.prototype.toUTCString.call("2000");         // TypeError
Date.prototype.toUTCString.call({});             // TypeError

Konwersja do formatu ISO - toISOString

Jak zamienić datę i czas na tekst zapisany w formacie ze standardem ISO?

(interpretuje: Internet Explorer 9, Firefox 3.5, Opera 10.50, Chrome)

Date.prototype.toISOString()
Wartość:
String - data i czas
Wyjątki:
RangeError - bieżący obiekt nie zawiera poprawnego daty i czasu
TypeError - bieżący obiekt nie jest typu daty i czasu

Działa analogicznie jak Date.prototype.toString, ale zwraca datę i czas formacie zgodnym z Date.parse zawsze w postaci pełnej wersji w strefie czasowej południka zerowego (zapisanej jako Z).

Przykład Date.prototype.toISOString

new Date("1410-07-15T13:30:59.000+02:00").toISOString(); // np.: "1410-07-15T11:30:59.000Z"
 
new Date(Infinity).toISOString();                // RangeError
 
Date.prototype.toISOString.call(null);           // TypeError
Date.prototype.toISOString.call(undefined);      // TypeError
Date.prototype.toISOString.call(0);              // TypeError
Date.prototype.toISOString.call("");             // TypeError
Date.prototype.toISOString.call("2000");         // TypeError
Date.prototype.toISOString.call({});             // TypeError

Konwersja do formatu JSON - toJSON

W jaki sposób następuje konwersja obiektu daty i czasu do formatu JSON?

Date.prototype.toJSON()
Date.prototype.toJSON(key)
Parametry:
String key - klucz JSON (nieużywane)
Wartość:
String - data i czas
Wyjątki:
TypeError - bieżący obiekt nie posiada metody toISOString

Działa identycznie jak Date.prototype.toISOString. Przeznaczeniem tej metody jest jednak przygotowanie tekstowej reprezentacji obiektu daty i czasu, używanej później przez funkcję JSON.stringify.

Argument key - przekazywany przez JSON.stringify - normalnie jest ignorowany, ale możemy go wykorzystać we własnej implementacji tej metody.

Przykład Date.prototype.toJSON

JSON.stringify(new Date(1410, 6, 15)); // "\"1410-07-14T22:00:00.000Z\""
 
var Cls = function () {};
Cls.prototype.toJSON = function (key) {
    return Date.prototype.toJSON.call(this, key);
};
JSON.stringify(new Cls());                             // TypeError
Facebook