JavaScript
Datum

Syntax

• neues Datum();
• neues Datum (Wert);
• neues Datum (dateAsString);
• neues Datum (Jahr, Monat [, Tag [, Stunde [, Minute [, Sekunde [, Millisekunde]]]]];

Parameter

Holen Sie sich die aktuelle Uhrzeit und das aktuelle Datum

Verwenden Sie new Date() , um ein neues Date Objekt mit dem aktuellen Datum und der aktuellen Uhrzeit zu generieren.

Beachten Sie, dass Date() das ohne Argumente aufgerufen wird, dem new Date(Date.now()) .

Wenn Sie ein getFullYear() haben, können Sie eine der verschiedenen verfügbaren Methoden anwenden, um seine Eigenschaften zu extrahieren (z. B. getFullYear() , um das vierstellige Jahr zu erhalten).

Nachfolgend finden Sie einige gängige Datumsmethoden.

Holen Sie sich das aktuelle Jahr

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

Holen Sie sich den aktuellen Monat

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

Bitte beachten Sie, dass 0 = Januar ist. Dies liegt daran, dass die Monate zwischen 0 und 11 liegen. Daher ist es häufig wünschenswert, +1 zum Index hinzuzufügen.

Holen Sie sich den aktuellen Tag

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

Holen Sie sich die aktuelle Stunde

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

Holen Sie sich die aktuellen Minuten

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

Holen Sie sich die aktuellen Sekunden

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

Holen Sie sich die aktuellen Millisekunden

Um die Millisekunden (im Bereich von 0 bis 999) einer Instanz eines Date Objekts getMilliseconds , verwenden Sie die getMilliseconds Methode.

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

Konvertieren Sie die aktuelle Uhrzeit und das aktuelle Datum in eine vom Menschen lesbare Zeichenfolge

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

Die statische Methode Date.now() gibt die Anzahl der seit dem 1. Januar 1970 um 00:00:00 UTC verstrichenen Millisekunden zurück. Um die Anzahl der Millisekunden zu ermitteln, die seit dieser Zeit mithilfe einer Instanz eines Date Objekts vergangen sind, verwenden Sie die getTime Methode.

// 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());

Erstellen Sie ein neues Date-Objekt

Um ein neues Date Objekt zu erstellen, verwenden Sie den Date() Konstruktor:

• ohne Argumente

  Date() erstellt eine Date Instanz mit der aktuellen Uhrzeit (bis zu Millisekunden) und dem Datum.

• mit einem ganzzahligen Argument

  Date(m) erzeugt ein Date Beispiel die Uhrzeit und das Datum entsprechend die Epoch Zeit , die (1. Januar 1970 UTC) und m Millisekunden. Beispiel: new Date(749019369738) gibt das Datum an So, 26 Sep 1993 04:56:09 GMT .

• mit einem String-Argument

  Date(dateString) gibt das Date Objekt zurück, das nach dem Analysieren von dateString mit Date.parse .

• mit zwei oder mehr ganzzahligen Argumenten

  Date(i1, i2, i3, i4, i5, i6) liest die Argumente als Jahr, Monat, Tag, Stunden, Minuten, Sekunden, Millisekunden und instanziiert das entsprechende Date Objekt. Beachten Sie, dass der Monat in JavaScript 0-indexiert ist. 0 bedeutet also Januar und 11 Dezember. Beispiel: new Date(2017, 5, 1) gibt den 1. Juni 2017 an .

Termine erkunden

Beachten Sie, dass diese Beispiele während der Sommerzeit in einem Browser in der zentralen Zeitzone der USA generiert wurden, wie der Code zeigt. Wenn der Vergleich mit UTC Date.prototype.toISOString() war, wurde Date.prototype.toISOString() verwendet, um Datum und Uhrzeit in UTC Date.prototype.toISOString() das Z in der formatierten Zeichenfolge steht für 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

Konvertieren Sie in JSON

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

Rückkehr: "2016-04-14T23: 49: 08.596Z"

Datum aus UTC erstellen

Standardmäßig wird ein Date Objekt als Ortszeit erstellt. Dies ist nicht immer wünschenswert, wenn beispielsweise ein Datum zwischen einem Server und einem Client kommuniziert wird, die sich nicht in derselben Zeitzone befinden. In diesem Szenario möchte man sich keine Sorgen über Zeitzonen machen, bis das Datum in Ortszeit angezeigt wird, falls dies überhaupt erforderlich ist.

Das Problem

In diesem Problem möchten wir ein bestimmtes Datum (Tag, Monat, Jahr) mit jemandem in einer anderen Zeitzone kommunizieren. Die erste Implementierung verwendet naiv lokale Zeiten, was zu falschen Ergebnissen führt. Die zweite Implementierung verwendet UTC-Daten, um Zeitzonen zu vermeiden, in denen sie nicht benötigt werden.

Naiver Ansatz mit falschen Ergebnissen

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());

Produktionsbeispiel: 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()));

Produktionsbeispiel: Foo was born on: Fri Dec 31 1999

Und so glaubte Bar immer, dass Foo am letzten Tag des Jahres 1999 geboren wurde.

Richtige Annäherung

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());

Produktionsbeispiel: 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()));

Produktionsbeispiel: Foo was born on: Sat Jan 1 2000

Datum aus UTC erstellen

Wenn Sie ein Date Objekt basierend auf UTC oder GMT erstellen Date.UTC(...) , kann die Date.UTC(...) -Methode verwendet werden. Es verwendet die gleichen Argumente wie der längste Date Konstruktor. Diese Methode gibt eine Zahl zurück, die die seit dem 1. Januar 1970 um 00:00:00 UTC verstrichene Zeit angibt.

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

Beispielausgabe: 949320000000

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

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

Es ist nicht überraschend, dass der Unterschied zwischen UTC-Zeit und Ortszeit tatsächlich der in Millisekunden konvertierte Zeitzonenversatz ist.

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);

Beispielausgabe: true

Ändern eines Date-Objekts

Alle Date Objektmodifizierer wie setDate(...) und setFullYear(...) haben ein Äquivalent, das ein Argument in UTC-Zeit und nicht in Ortszeit enthält.

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

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

Die anderen UTC-spezifischen Modifizierer sind .setUTCMonth() , .setUTCDate() (für den Tag des Monats), .setUTCMinutes() , .setUTCSeconds() und .setUTCMilliseconds() .

Mehrdeutigkeit mit getTime () und setTime () vermeiden

Wenn die oben genannten Methoden erforderlich sind, um zwischen Mehrdeutigkeiten in Datumsangaben zu unterscheiden, ist es normalerweise einfacher, ein Datum als die seit dem 1. Januar 1970, 00:00:00 UTC, verstrichene Zeit anzugeben. Diese einzelne Zahl stellt einen einzelnen Zeitpunkt dar und kann bei Bedarf in lokale Zeit umgewandelt werden.

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);

Beispielausgabe: 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);

Beispielausgabe:

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

Konvertieren Sie in ein String-Format

In String konvertieren

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

Rückkehr: "Fr Apr 15 2016 07:48:48 GMT-0400 (Östliche Sommerzeit)"

Konvertieren Sie in Zeitzeichenfolge

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

Rückgabe: "07:48:48 GMT-0400 (östliche Sommerzeit)"

Konvertierung in Datumszeichenfolge

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

Rückgabe: "Do 14 Apr 2016"

Konvertieren Sie in UTC-Zeichenfolge

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

Rückkehr: "Fr, 15 Apr 2016 11:48:48 GMT"

In ISO-Zeichenfolge konvertieren

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

Rückkehr: "2016-04-14T23: 49: 08.596Z"

Konvertieren Sie in GMT String

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

Rückkehr: "Do 14.04.2016 23:49:08 GMT"

Diese Funktion wurde als veraltet markiert, sodass einige Browser sie in Zukunft möglicherweise nicht mehr unterstützen. Es wird empfohlen, stattdessen toUTCString () zu verwenden.

In Locale-Datumszeichenfolge konvertieren

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

Rückgabe: "14.04.2016"

Diese Funktion gibt eine für das Gebietsschema relevante Datumszeichenfolge basierend auf dem Standort des Benutzers standardmäßig zurück.

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

kann verwendet werden, um bestimmte Gebietsschemas bereitzustellen, ist jedoch für die Browserimplementierung spezifisch. Zum Beispiel,

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

würde versuchen, die Zeichenfolge im chinesischen Gebietsschema zu drucken, wobei Englisch als Fallback verwendet wird. Der options-Parameter kann verwendet werden, um bestimmte Formatierungen bereitzustellen. Zum Beispiel:

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

würde ergeben

"Donnerstag, 14. April 2016".

Weitere Informationen finden Sie im MDN .

Inkrementieren Sie ein Datumsobjekt

Um Datumsobjekte in Javascript inkrementieren zu können, können wir normalerweise Folgendes tun:

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)

Es ist möglich, setDate zu verwenden, um das Datum in einen Tag im folgenden Monat zu ändern, indem Sie einen Wert verwenden, der größer ist als die Anzahl der Tage im aktuellen Monat.

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)

Gleiches gilt für andere Methoden wie getHours (), getMonth () usw.

Arbeitstage hinzufügen

Wenn Sie Arbeitstage hinzufügen möchten (in diesem Fall setDate ich von Montag bis Freitag), können Sie die Funktion setDate verwenden, obwohl Sie ein wenig zusätzliche Logik benötigen, um die Wochenenden zu berücksichtigen.

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;
}

Ermitteln Sie die Anzahl der seit dem 1. Januar 1970 um 00:00:00 UTC abgelaufenen Millisekunden

Die statische Methode Date.now gibt die Anzahl der seit dem 1. Januar 1970 um 00:00:00 UTC verstrichenen Millisekunden zurück. Um die Anzahl der Millisekunden zu ermitteln, die seit dieser Zeit mithilfe einer Instanz eines Date Objekts vergangen sind, verwenden Sie die getTime Methode.

// 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());

Formatieren eines JavaScript-Datums

Formatieren eines JavaScript-Datums in modernen Browsern

In modernen Browsern (*), Date.prototype.toLocaleDateString() können Sie die Formatierung eines definieren Date auf bequeme Weise.

Es erfordert das folgende Format:

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

Der locales Parameter sollte eine Zeichenfolge mit einem BCP 47-Sprachkennzeichen oder ein Array solcher Zeichenfolgen sein.

Der options Parameter sollte ein Objekt mit einigen oder allen der folgenden Eigenschaften sein:

• localeMatcher : Mögliche Werte sind "lookup" und "best fit" . Die Standardeinstellung ist "best fit"
• Zeitzone : Die einzigen Wertimplementierungen, die erkannt werden müssen, sind "UTC" ; Die Standardeinstellung ist die Standardzeitzone der Laufzeitumgebung
• hour12 : mögliche Werte sind true und false ; Die Standardeinstellung ist abhängig vom Gebietsschema
• formatMatcher : Mögliche Werte sind "basic" und "best fit" ; Die Standardeinstellung ist "best fit"
• Wochentag : Mögliche Werte sind "narrow" , "short" und "long"
• Ära : Mögliche Werte sind "narrow" , "short" & "long"
• Jahr : Mögliche Werte sind "numeric" und "2-digit"
• Monat : Mögliche Werte sind "numeric" , "2-digit" , "narrow" , "short" & "long"
• Tag : Mögliche Werte sind "numeric" und "2-digit"
• Stunde : Mögliche Werte sind "numeric" und "2-digit"
• Minute : Mögliche Werte sind "numeric" und "2-digit"
• Zweitens : Mögliche Werte sind "numeric" und "2-digit"
• timeZoneName : mögliche Werte sind "short" und "long"

Wie benutzt man

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

Ausgabe, wenn am 24. Januar 2036 ausgeführt:

'24 Jan 2036'

Gewohnheit gehen

Wenn Date.prototype.toLocaleDateString() nicht flexibel genug ist, um Date.prototype.toLocaleDateString() zu erfüllen, können Sie ein benutzerdefiniertes Date-Objekt erstellen, das folgendermaßen aussieht:

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;
})();

Wenn Sie diesen Code new DateObject() am 20. Januar 2019 ein new DateObject() ausgeführt haben, wird ein Objekt mit den folgenden Eigenschaften erzeugt:

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

Um eine formatierte Zeichenfolge zu erhalten, können Sie Folgendes tun:

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

Das würde die folgende Ausgabe erzeugen:

20-01-2016

(*) Nach dem MDN "modernen Browser" bedeutet Chrome 24+, 29+ Firefox, IE11, Kante 12 +, Opera 15+ & Safari nächtlichen bauen