JavaScript
Datum

Syntax

• nytt datum ();
• nytt datum (värde);
• nytt datum (dateAsString);
• nytt datum (år, månad [, dag [, timme [, minut [, sekund [, millisekund]]]]]);

parametrar

Få aktuell tid och datum

Använd new Date() att generera ett nytt Date innehåller aktuellt datum och tid.

Observera att Date() anropas utan argument motsvarar new Date(Date.now()) .

När du har ett datumobjekt kan du använda någon av de olika tillgängliga metoderna för att extrahera dess egenskaper (t.ex. getFullYear() att få 4-siffriga år).

Nedan finns några vanliga datummetoder.

Få det aktuella året

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

Få den aktuella månaden

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

Observera att 0 = januari. Detta beror på att månaderna sträcker sig från 0 till 11 , så det är ofta önskvärt att lägga till +1 i indexet.

Få den aktuella dagen

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

Få den aktuella timmen

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

Få de aktuella minuterna

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

Få de aktuella sekunderna

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

Få de nuvarande millisekunden

För att få millisekunder (från 0 till 999) för en instans av ett Date objekt använder du dess getMilliseconds metod.

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

Konvertera aktuell tid och datum till en sträng som kan läsas av människor

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

Den statiska metoden Date.now() returnerar antalet millisekunder som har gått sedan 1 januari 1970 00:00:00 UTC. För att få antalet millisekunder som har gått sedan den tiden med en instans av ett Date objekt använder du dess getTime metod.

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

Skapa ett nytt datumobjekt

För att skapa ett nytt Date använder du konstruktören Date() :

• utan argument

  Date() skapar en Date instans som innehåller den aktuella tiden (upp till millisekunder) och datum.

• med ett heltalargument

  Date(m) skapar ett Date instans som innehåller tid och datum som motsvarar den Epok tid (den 1 januari, 1970 UTC) plus m millisekunder. Exempel: new Date(749019369738) ger datumet Sun, 26 Sep 1993 04:56:09 GMT .

• med ett strängargument

  Date(dateString) returnerar Date objektet som blir resultatet efter parsing dateString med Date.parse .

• med två eller flera heltalargument

  Date(i1, i2, i3, i4, i5, i6) läser argumenten som år, månad, dag, timmar, minuter, sekunder, millisekunder och instanser motsvarande Date . Observera att månaden är 0-indexerad i JavaScript, så 0 betyder januari och 11 betyder december. Exempel: new Date(2017, 5, 1) ger 1 juni 2017 .

Utforska datum

Observera att dessa exempel genererades i en webbläsare i USA: s centrala tidszon under sommartid, vilket framgår av koden. Där jämförelsen med UTC var instruktiv, Date.prototype.toISOString() för att visa datum och tid i UTC (Z i den formaterade strängen anger 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

Konvertera till JSON

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

Returnerar: "2016-04-14T23: 49: 08.596Z"

Skapa ett datum från UTC

Som standard skapas ett Date som lokal tid. Detta är inte alltid önskvärt, till exempel när du kommunicerar ett datum mellan en server och en klient som inte finns i samma tidszon. I det här scenariot vill man inte oroa sig för tidszoner alls förrän datumet måste visas i lokal tid, om det ens krävs alls.

Problemet

I det här problemet vill vi kommunicera ett specifikt datum (dag, månad, år) med någon i en annan tidszon. Den första implementeringen använder naivt lokal tid, vilket resulterar i fel resultat. Den andra implementeringen använder UTC-datum för att undvika tidszoner där de inte behövs.

Naiv metod med FELA resultat

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

Provutgång: 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()));

Provutgång: Foo was born on: Fri Dec 31 1999

Och därmed skulle Bar alltid tro att Foo föddes den sista dagen 1999.

Rätt tillvägagångssätt

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

Provutgång: 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()));

Provutgång: Foo was born on: Sat Jan 1 2000

Skapa ett datum från UTC

Om man vill skapa ett Date objekt baserat på UTC eller GMT, kan Date.UTC(...) användas. Den använder samma argument som den längsta Date konstruktören. Denna metod kommer att returnera ett nummer som representerar tiden som har gått sedan 1 januari 1970, 00:00:00 UTC.

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

949320000000 : 949320000000

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

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

Det är inte förvånande att skillnaden mellan UTC-tid och lokal tid faktiskt är tidszonerna som kompenseras till millisekunder.

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

Provutgång: true

Ändra ett datumobjekt

Alla Date objekt medel, såsom setDate(...) och setFullYear(...) har en motsvarande tar ett argument i UTC-tid i stället för i lokal tid.

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

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

De andra UTC-specifika modifierarna är .setUTCMonth() , .setUTCDate() (för .setUTCMinutes() månad), .setUTCMinutes() , .setUTCSeconds() och .setUTCMilliseconds() .

Undvik tvetydighet med getTime () och setTime ()

Där metoderna ovan krävs för att skilja mellan tvetydighet i datum är det vanligtvis lättare att kommunicera ett datum som den tid som har gått sedan 1 januari 1970, 00:00:00 UTC. Detta enda nummer representerar en enda tidpunkt och kan konverteras till lokal tid när det behövs.

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

Provutgång: 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);

Provutgång:

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

Konvertera till ett strängformat

Konvertera till sträng

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

Returnerar: "Fre 15 april 2016 07:48:48 GMT-0400 (Eastern Daylight Time)"

Konvertera till Time String

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

Returnerar: "07:48:48 GMT-0400 (Eastern Daylight Time)"

Konvertera till datumsträng

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

Returnerar: "Thu 14 apr 2016"

Konvertera till UTC-sträng

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

Returnerar: "Fre, 15 april 2016 11:48:48 GMT"

Konvertera till ISO-sträng

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

Returnerar: "2016-04-14T23: 49: 08.596Z"

Konvertera till GMT String

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

Returnerar: "Thu, 14 Apr 2016 23:49:08 GMT"

Denna funktion har markerats som föråldrad så att vissa webbläsare kanske inte stöder den i framtiden. Det rekommenderas att använda toUTCString () istället.

Konvertera till Strängdatumsträng

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

Returnerar: "14.4.2016"

Denna funktion returnerar en lokal känslig datumsträng baserad på användarens plats som standard.

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

kan användas för att tillhandahålla specifika platser men är specifik för webbläsarimplementering. Till exempel,

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

skulle försöka skriva ut strängen i det kinesiska landskapet med hjälp av United States English som ett fallback. Alternativparametern kan användas för att tillhandahålla specifik formatering. Till exempel:

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

skulle resultera i

"Torsdagen den 14 april 2016".

Se MDN för mer information.

Öka ett datumobjekt

För att öka datumobjekt i Javascript kan vi vanligtvis göra detta:

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)

Det är möjligt att använda setDate att ändra datumet till en dag i följande månad genom att använda ett värde som är större än antalet dagar i den aktuella månaden -

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)

Detsamma gäller för andra metoder som getHours (), getMonth () osv.

Lägga till arbetsdagar

Om du vill lägga till arbetsdagar (i det här fallet antar jag måndag - fredag) kan du använda setDate funktionen även om du behöver lite extra logik för att redovisa helgerna (detta kommer naturligtvis inte att ta hänsyn till nationella helgdagar) -

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

Få antalet millisekunder som gått sedan 1 januari 1970 00:00:00 UTC

Den statiska metoden Date.now returnerar antalet millisekunder som har gått sedan 1 januari 1970 00:00:00 UTC. För att få antalet millisekunder som har gått sedan den tiden med en instans av ett Date objekt använder du dess getTime metod.

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

Formatera ett JavaScript-datum

Formatera ett JavaScript-datum i moderna webbläsare

I moderna webbläsare (*) Date.prototype.toLocaleDateString() definiera formateringen av ett Date på ett bekvämt sätt.

Det kräver följande format:

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

locales parametern bör vara en sträng med en BCP 47-spårtagg eller en matris med sådana strängar.

options ska vara ett objekt med några eller alla av följande egenskaper:

• localeMatcher : möjliga värden är "lookup" och "best fit" ; standard är "best fit"
• timeZone : de enda värden som implementeringarna måste känna igen är "UTC" ; standard är runtime's standardtidszon
• timme12 : möjliga värden är true och false ; standard är beroende på land
• formatMatcher : möjliga värden är "basic" och "best fit" ; standard är "best fit"
• vardag : möjliga värden är "narrow" , "short" och "long"
• era : möjliga värden är "narrow" , "short" och "long"
• år : möjliga värden är "numeric" och "2-digit"
• månad : möjliga värden är "numeric" , "2-digit" , "narrow" , "short" och "long"
• dag : möjliga värden är "numeric" och "2-digit"
• timme : möjliga värden är "numeric" och "2-digit"
• minut : möjliga värden är "numeric" och "2-digit"
• andra : möjliga värden är "numeric" och "2-digit"
• timeZoneName : möjliga värden är "short" och "long"

Hur man använder

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

Output om den körs 24 januari 2036:

'24 Jan 2036'

Går anpassad

Om Date.prototype.toLocaleDateString() är tillräckligt flexibel för att uppfylla det behov du behöver, kanske du vill överväga att skapa ett anpassat datumobjekt som ser ut så här:

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

Om du inkluderade den koden och new DateObject() 20 januari 2019, skulle det producera ett objekt med följande egenskaper:

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

För att få en formaterad sträng kan du göra något liknande:

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

Det skulle producera följande utgång:

20-01-2016

(*) Enligt MDN betyder "moderna webbläsare" Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ & Safari nattlig byggnad