JavaScript
Data

Składnia

• Nowa data();
• nowa data (wartość);
• nowa data (dateAsString);
• nowa data (rok, miesiąc [, dzień [, godzina [, minuta [, sekunda [, milisekunda]]]]]);

Parametry

Uzyskaj aktualną godzinę i datę

Użyj new Date() aby wygenerować nowy obiekt Date zawierający bieżącą datę i godzinę.

Zauważ, że Date() wywoływana bez argumentów jest równoważna new Date(Date.now()) .

Po utworzeniu obiektu daty możesz zastosować dowolną z kilku dostępnych metod w celu wyodrębnienia jego właściwości (np. getFullYear() aby uzyskać 4-cyfrowy rok).

Poniżej przedstawiono niektóre typowe metody dat.

Uzyskaj bieżący rok

var year = (new Date()).getFullYear();
console.log(year);
// Sample output: 2016 

Uzyskaj bieżący miesiąc

var month = (new Date()).getMonth();
console.log(month);
// Sample output: 0 

Uwaga: 0 = styczeń. Wynika to z tego, że miesiące wahają się od 0 do 11 , dlatego często pożądane jest dodanie +1 do indeksu.

Uzyskaj bieżący dzień

var day = (new Date()).getDate();
console.log(day);
// Sample output: 31

Uzyskaj aktualną godzinę

var hours = (new Date()).getHours();
console.log(hours);
// Sample output: 10

Uzyskaj aktualne minuty

var minutes = (new Date()).getMinutes();
console.log(minutes);
// Sample output: 39

Uzyskaj aktualne sekundy

var seconds = (new Date()).getSeconds();
console.log(second);
// Sample output: 48

Pobierz bieżące milisekundy

Aby uzyskać milisekundy (od 0 do 999) wystąpienia obiektu Date , użyj jego metody getMilliseconds .

var milliseconds = (new Date()).getMilliseconds();
console.log(milliseconds);
 // Output: milliseconds right now

Konwertuj bieżącą godzinę i datę na ciąg czytelny dla człowieka

var now = new Date();
// convert date to a string in UTC timezone format:
console.log(now.toUTCString());
// Output: Wed, 21 Jun 2017 09:13:01 GMT

Metoda statyczna Date.now() zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970 r. 00:00:00 UTC. Aby uzyskać liczbę milisekund, które upłynęły od tego czasu przy użyciu instancji obiektu Date , użyj jego getTime .

// get milliseconds using static method now of Date
console.log(Date.now());

// get milliseconds using method getTime of Date instance
console.log((new Date()).getTime());

Utwórz nowy obiekt Data

Aby utworzyć nowy obiekt Date użyj konstruktora Date() :

• bez argumentów

  Date() tworzy instancję Date zawierającą bieżącą godzinę (do milisekund) i datę.

• z jednym argumentem liczb całkowitych

  Date(m) tworzy instancję Date zawierającą godzinę i datę odpowiadającą czasowi Epoki (1 stycznia 1970 r. UTC) plus m milisekund. Przykład: new Date(749019369738) podaje datę niedz., 26 września 1993 04:56:09 GMT .

• z argumentem łańcuchowym

  Date(dateString) zwraca obiekt Date powstały po dateString pomocą Date.parse .

• z dwoma lub więcej liczbami całkowitymi

  Date(i1, i2, i3, i4, i5, i6) odczytuje argumenty jako rok, miesiąc, dzień, godziny, minuty, sekundy, milisekundy i tworzy instancję odpowiedniego obiektu Date . Pamiętaj, że miesiąc w JavaScript jest indeksowany jako 0, więc 0 oznacza styczeń, a 11 oznacza grudzień. Przykład: new Date(2017, 5, 1) podaje new Date(2017, 5, 1) czerwca 2017 r .

Odkrywanie dat

Pamiętaj, że przykłady te zostały wygenerowane w przeglądarce w środkowej strefie czasowej Stanów Zjednoczonych, w czasie dziennym, o czym świadczy kod. Tam, gdzie porównanie z UTC było pouczające, zastosowano Date.prototype.toISOString() do wyświetlenia daty i godziny w UTC (Z w sformatowanym ciągu oznacza UTC).

// Creates a Date object with the current date and time from the 
// user's browser
var now = new Date();
now.toString() === 'Mon Apr 11 2016 16:10:41 GMT-0500 (Central Daylight Time)' 
// true
// well, at the time of this writing, anyway

// Creates a Date object at the Unix Epoch (i.e., '1970-01-01T00:00:00.000Z')
var epoch = new Date(0);
epoch.toISOString() === '1970-01-01T00:00:00.000Z' // true

// Creates a Date object with the date and time 2,012 milliseconds 
// after the Unix Epoch (i.e., '1970-01-01T00:00:02.012Z').
var ms = new Date(2012); 
date2012.toISOString() === '1970-01-01T00:00:02.012Z' // true

// Creates a Date object with the first day of February of the year 2012 
// in the local timezone.
var one = new Date(2012, 1);
one.toString() === 'Wed Feb 01 2012 00:00:00 GMT-0600 (Central Standard Time)' 
// true

// Creates a Date object with the first day of the year 2012 in the local 
// timezone.
// (Months are zero-based) 
var zero = new Date(2012, 0);
zero.toString() === 'Sun Jan 01 2012 00:00:00 GMT-0600 (Central Standard Time)' 
// true

// Creates a Date object with the first day of the year 2012, in UTC.
var utc = new Date(Date.UTC(2012, 0));
utc.toString() === 'Sat Dec 31 2011 18:00:00 GMT-0600 (Central Standard Time)'
// true
utc.toISOString() === '2012-01-01T00:00:00.000Z'
// true

// Parses a string into a Date object (ISO 8601 format added in ECMAScript 5.1)
// Implementations should assumed UTC because of ISO 8601 format and Z designation
var iso = new Date('2012-01-01T00:00:00.000Z');
iso.toISOString() === '2012-01-01T00:00:00.000Z' // true

// Parses a string into a Date object (RFC in JavaScript 1.0)
var local = new Date('Sun, 01 Jan 2012 00:00:00 -0600');
local.toString() === 'Sun Jan 01 2012 00:00:00 GMT-0600 (Central Standard Time)'
// true

// Parses a string in no particular format, most of the time. Note that parsing
// logic in these cases is very implementation-dependent, and therefore can vary
// across browsers and versions.
var anything = new Date('11/12/2012'); 
anything.toString() === 'Mon Nov 12 2012 00:00:00 GMT-0600 (Central Standard Time)'
// true, in Chrome 49 64-bit on Windows 10 in the en-US locale. Other versions in 
// other locales may get a different result.

// Rolls values outside of a specified range to the next value.
var rollover = new Date(2012, 12, 32, 25, 62, 62, 1023);
rollover.toString() === 'Sat Feb 02 2013 02:03:03 GMT-0600 (Central Standard Time)'
// true; note that the month rolled over to Feb; first the month rolled over to 
// Jan based on the month 12 (11 being December), then again because of the day 32
// (January having 31 days).

// Special dates for years in the range 0-99
var special1 = new Date(12, 0);
special1.toString() === 'Mon Jan 01 1912 00:00:00 GMT-0600 (Central Standard Time)`
// true

// If you actually wanted to set the year to the year 12 CE, you'd need to use the
// setFullYear() method:
special1.setFullYear(12);
special1.toString() === 'Sun Jan 01   12 00:00:00 GMT-0600 (Central Standard Time)`
// true

Konwertuj na JSON

var date1 = new Date();
date1.toJSON();

Zwraca: „2016-04-14T23: 49: 08.596Z”

Tworzenie daty z UTC

Domyślnie obiekt Date jest tworzony jako czas lokalny. Nie zawsze jest to pożądane, na przykład podczas komunikowania daty między serwerem a klientem, który nie znajduje się w tej samej strefie czasowej. W tym scenariuszu nie trzeba się martwić strefami czasowymi, dopóki data nie musi być wyświetlana w czasie lokalnym, jeśli jest to w ogóle wymagane.

Problem

W tym problemie chcemy przekazać konkretną datę (dzień, miesiąc, rok) komuś w innej strefie czasowej. Pierwsza implementacja naiwnie wykorzystuje czasy lokalne, co skutkuje błędnymi wynikami. Druga implementacja wykorzystuje daty UTC, aby uniknąć stref czasowych, w których nie są one potrzebne.

Naiwne podejście z błędnymi wynikami

function formatDate(dayOfWeek, day, month, year) {
  var daysOfWeek = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
  var months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
  return daysOfWeek[dayOfWeek] + " " + months[month] + " " + day + " " + year;
}

//Foo lives in a country with timezone GMT + 1
var birthday = new Date(2000,0,1);
console.log("Foo was born on: " + formatDate(birthday.getDay(), birthday.getDate(),
      birthday.getMonth(), birthday.getFullYear()));

sendToBar(birthday.getTime());

Przykładowe dane wyjściowe: Foo was born on: Sat Jan 1 2000

//Meanwhile somewhere else...

//Bar lives in a country with timezone GMT - 1
var birthday = new Date(receiveFromFoo());
console.log("Foo was born on: " + formatDate(birthday.getDay(), birthday.getDate(),
      birthday.getMonth(), birthday.getFullYear()));

Przykładowy wynik: Foo was born on: Fri Dec 31 1999

I dlatego Bar zawsze wierzył, że Foo urodził się ostatniego dnia 1999 roku.

Prawidłowe podejście

function formatDate(dayOfWeek, day, month, year) {
  var daysOfWeek = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
  var months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
  return daysOfWeek[dayOfWeek] + " " + months[month] + " " + day + " " + year;
}

//Foo lives in a country with timezone GMT + 1
var birthday = new Date(Date.UTC(2000,0,1));
console.log("Foo was born on: " + formatDate(birthday.getUTCDay(), birthday.getUTCDate(),
      birthday.getUTCMonth(), birthday.getUTCFullYear()));

sendToBar(birthday.getTime());

Przykładowe dane wyjściowe: Foo was born on: Sat Jan 1 2000

//Meanwhile somewhere else...

//Bar lives in a country with timezone GMT - 1
var birthday = new Date(receiveFromFoo());
console.log("Foo was born on: " + formatDate(birthday.getUTCDay(), birthday.getUTCDate(), 
      birthday.getUTCMonth(), birthday.getUTCFullYear()));

Przykładowe dane wyjściowe: Foo was born on: Sat Jan 1 2000

Tworzenie daty z UTC

Jeśli chce się utworzyć obiekt Date na podstawie UTC lub GMT, można zastosować metodę Date.UTC(...) . Używa tych samych argumentów, co najdłuższy konstruktor Date . Ta metoda zwróci liczbę reprezentującą czas, który upłynął od 1 stycznia 1970 r., 00:00:00 UTC.

console.log(Date.UTC(2000,0,31,12));

Przykładowe dane wyjściowe: 949320000000

var utcDate = new Date(Date.UTC(2000,0,31,12));
console.log(utcDate);

Przykładowe dane wyjściowe: Mon Jan 31 2000 13:00:00 GMT+0100 (West-Europa (standaardtijd))

Nic dziwnego, że różnica między czasem UTC a czasem lokalnym jest w rzeczywistości przesunięciem strefy czasowej przeliczonym na milisekundy.

var utcDate = new Date(Date.UTC(2000,0,31,12));
var localDate = new Date(2000,0,31,12);

console.log(localDate - utcDate === utcDate.getTimezoneOffset() * 60 * 1000);

Przykładowe dane wyjściowe: true

Zmiana obiektu daty

Wszystkie modyfikatory obiektu Date , takie jak setDate(...) i setFullYear(...) mają odpowiednik, przyjmują argument w czasie UTC, a nie w czasie lokalnym.

var date = new Date();
date.setUTCFullYear(2000,0,31);
date.setUTCHours(12,0,0,0);
console.log(date);

Przykładowe dane wyjściowe: Mon Jan 31 2000 13:00:00 GMT+0100 (West-Europa (standaardtijd))

Inne specyficzne dla UTC modyfikatory to .setUTCMonth() , .setUTCDate() (na dzień miesiąca), .setUTCMinutes() , .setUTCSeconds() i .setUTCMilliseconds() .

Unikanie dwuznaczności za pomocą getTime () i setTime ()

Tam, gdzie wymagane są powyższe metody w celu rozróżnienia między niejednoznacznością dat, zwykle łatwiej jest podać datę jako czas, który upłynął od 1 stycznia 1970 r., 00:00:00 UTC. Ten pojedynczy numer reprezentuje jeden punkt w czasie i może być w razie potrzeby konwertowany na czas lokalny.

var date = new Date(Date.UTC(2000,0,31,12));
var timestamp = date.getTime();
//Alternatively
var timestamp2 = Date.UTC(2000,0,31,12);
console.log(timestamp === timestamp2);

Przykładowe dane wyjściowe: true

//And when constructing a date from it elsewhere...
var otherDate = new Date(timestamp);

//Represented as an universal date
console.log(otherDate.toUTCString());
//Represented as a local date
console.log(otherDate);

Przykładowe dane wyjściowe:

Mon, 31 Jan 2000 12:00:00 GMT
Mon Jan 31 2000 13:00:00 GMT+0100 (West-Europa (standaardtijd))

Konwertuj na format ciągu

Konwertuj na ciąg

var date1 = new Date();
date1.toString();

Zwraca: „Pt 15 kwietnia 2016 07:48:48 GMT-0400 (Wschodni czas letni)”

Konwertuj na ciąg czasu

var date1 = new Date();
date1.toTimeString();

Zwraca: „07:48:48 GMT-0400 (wschodni czas letni)”

Konwertuj na ciąg daty

var date1 = new Date();
date1.toDateString();

Zwraca: „czw 14 kwietnia 2016 r.”

Konwertuj na ciąg UTC

var date1 = new Date();
date1.toUTCString();

Zwraca: „Pt, 15 kwietnia 2016 11:48:48 GMT”

Konwertuj na ciąg ISO

var date1 = new Date();
date1.toISOString();

Zwraca: „2016-04-14T23: 49: 08.596Z”

Konwertuj na ciąg GMT

var date1 = new Date();
date1.toGMTString();

Zwraca: „czw., 14 kwietnia 2016 23:49:08 GMT”

Ta funkcja została oznaczona jako przestarzała, więc niektóre przeglądarki mogą nie obsługiwać jej w przyszłości. Sugeruje się użycie metody toUTCString ().

Konwertuj na ciąg daty ustawień regionalnych

var date1 = new Date();
date1.toLocaleDateString();

Zwraca: „14.04.2016”

Ta funkcja domyślnie zwraca ciąg daty wrażliwy na ustawienia narodowe na podstawie lokalizacji użytkownika.

date1.toLocaleDateString([locales [, options]])

może być użyty do zapewnienia określonych ustawień narodowych, ale zależy od implementacji przeglądarki. Na przykład,

date1.toLocaleDateString(["zh", "en-US"]);

spróbuje wydrukować ciąg w chińskich ustawieniach narodowych, używając angielskiego amerykańskiego jako rezerwowego. Parametru options można użyć do zapewnienia określonego formatowania. Na przykład:

var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
date1.toLocaleDateString([], options);

spowodowałoby

„Czwartek, 14 kwietnia 2016 r.”.

Zobacz MDN po więcej szczegółów.

Przyrost obiektu daty

Aby zwiększyć obiekty daty w JavaScript, zwykle możemy to zrobić:

var checkoutDate = new Date();    // Thu Jul 21 2016 10:05:13 GMT-0400 (EDT)

checkoutDate.setDate( checkoutDate.getDate() + 1 );

console.log(checkoutDate); // Fri Jul 22 2016 10:05:13 GMT-0400 (EDT)

Można użyć setDate aby zmienić datę na dzień w następnym miesiącu, używając wartości większej niż liczba dni w bieżącym miesiącu -

var checkoutDate = new Date();    // Thu Jul 21 2016 10:05:13 GMT-0400 (EDT)
checkoutDate.setDate( checkoutDate.getDate() + 12 );
console.log(checkoutDate); // Tue Aug 02 2016 10:05:13 GMT-0400 (EDT)

To samo dotyczy innych metod, takich jak getHours (), getMonth () itp.

Dodawanie dni roboczych

Jeśli chcesz dodać dni robocze (w tym przypadku setDate że poniedziałek - piątek) możesz użyć funkcji setDate chociaż potrzebujesz trochę dodatkowej logiki, aby uwzględnić weekendy (oczywiście nie będzie to uwzględniać świąt państwowych) -

function addWorkDays(startDate, days) {
    // Get the day of the week as a number (0 = Sunday, 1 = Monday, .... 6 = Saturday)
    var dow = startDate.getDay();
    var daysToAdd = days;
    // If the current day is Sunday add one day
    if (dow == 0)
        daysToAdd++;
    // If the start date plus the additional days falls on or after the closest Saturday calculate weekends
    if (dow + daysToAdd >= 6) {
        //Subtract days in current working week from work days
        var remainingWorkDays = daysToAdd - (5 - dow);
        //Add current working week's weekend
        daysToAdd += 2;
        if (remainingWorkDays > 5) {
            //Add two days for each working week by calculating how many weeks are included
            daysToAdd += 2 * Math.floor(remainingWorkDays / 5);
            //Exclude final weekend if remainingWorkDays resolves to an exact number of weeks
            if (remainingWorkDays % 5 == 0)
                daysToAdd -= 2;
        }
    }
    startDate.setDate(startDate.getDate() + daysToAdd);
    return startDate;
}

Uzyskaj liczbę milisekund, które upłynęły od 1 stycznia 1970 r. 00:00:00 UTC

Metoda statyczna Date.now zwraca liczbę milisekund, które upłynęły od 1 stycznia 1970 r. 00:00:00 UTC. Aby uzyskać liczbę milisekund, które upłynęły od tego czasu przy użyciu instancji obiektu Date , użyj jego getTime .

// get milliseconds using static method now of Date
console.log(Date.now());

// get milliseconds using method getTime of Date instance
console.log((new Date()).getTime());

Formatowanie daty JavaScript

Formatowanie daty JavaScript we współczesnych przeglądarkach

W nowoczesnych przeglądarkach (*) Date.prototype.toLocaleDateString() umożliwia wygodne zdefiniowanie formatowania Date .

Wymaga następującego formatu:

dateObj.toLocaleDateString([locales [, options]])

Parametr locales powinien być ciągiem ze znacznikiem języka BCP 47 lub tablicą takich ciągów.

Parametr options powinien być obiektem o niektórych lub wszystkich następujących właściwościach:

• localeMatcher : możliwe wartości to "lookup" i "best fit" ; domyślnie jest to "best fit"
• timeZone : jedyne implementacje wartości, które muszą rozpoznać, to "UTC" ; wartością domyślną jest domyślna strefa czasowa środowiska wykonawczego
• hour12 : możliwe wartości są true i false ; wartość domyślna zależy od ustawień regionalnych
• formatMatcher : możliwe wartości to "basic" i "best fit" ; domyślnie jest to "best fit"
• dzień tygodnia : możliwe wartości to "narrow" , "short" i "long"
• era : możliwe wartości to "narrow" , "short" i "long"
• rok : możliwe wartości to "numeric" i "2-digit"
• miesiąc : możliwe wartości to "numeric" , "2-digit" , "narrow" , "short" i "long"
• dzień : możliwe wartości to "numeric" i "2-digit"
• godzina : możliwe wartości to "numeric" i "2-digit"
• minuta : możliwe wartości to "numeric" i "2-digit"
• po drugie : możliwe wartości to "numeric" i "2-digit"
• timeZoneName : możliwe wartości to "short" i "long"

Jak używać

var today = new Date().toLocaleDateString('en-GB', {  
    day : 'numeric',
    month : 'short',
    year : 'numeric'
});

Dane wyjściowe, jeśli zostaną wykonane 24 stycznia 2036 r .:

'24 Jan 2036'

Będzie niestandardowy

Jeśli Date.prototype.toLocaleDateString() nie jest wystarczająco elastyczny, aby spełnić wszelkie potrzeby, możesz rozważyć utworzenie niestandardowego obiektu Date, który wygląda następująco:

var DateObject = (function() {
    var monthNames = [
      "January", "February", "March",
      "April", "May", "June", "July",
      "August", "September", "October",
      "November", "December"
    ];
    var date = function(str) {
        this.set(str);
    };
    date.prototype = {
        set : function(str) {
            var dateDef = str ? new Date(str) : new Date();
            this.day = dateDef.getDate();
            this.dayPadded = (this.day < 10) ? ("0" + this.day) : "" + this.day;
            this.month = dateDef.getMonth() + 1;
            this.monthPadded = (this.month < 10) ? ("0" + this.month) : "" + this.month;
            this.monthName = monthNames[this.month - 1];
            this.year = dateDef.getFullYear();
        },
        get : function(properties, separator) {
            var separator = separator ? separator : '-'
                ret = [];
            for(var i in properties) {
                ret.push(this[properties[i]]);
            }
            return ret.join(separator);
        }
    };
    return date;
})();

Jeśli new DateObject() ten kod i new DateObject() w dniu 20 stycznia 2019 r., Wygeneruje on obiekt o następujących właściwościach:

day: 20
dayPadded: "20"
month: 1
monthPadded: "01"
monthName: "January"
year: 2019

Aby uzyskać sformatowany ciąg, możesz zrobić coś takiego:

new DateObject().get(['dayPadded', 'monthPadded', 'year']);

To dałoby następujące wyniki:

20-01-2016

(*) Według MDN „nowoczesne przeglądarki” oznaczają Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ i Safari w wersji nocnej