JavaScript
Data

Sintassi

• nuova data ();
• nuova data (valore);
• nuova data (dataASstring);
• nuova data (anno, mese [, giorno [, ora [, minuto [, secondo [, millisecondo]]]]]);

Parametri

Ottieni l'ora e la data attuali

Utilizzare new Date() per generare un nuovo oggetto Date contenente la data e l'ora correnti.

Nota che Date() chiamato senza argomenti equivale a new Date(Date.now()) .

Una volta che hai un oggetto data, puoi applicare uno dei vari metodi disponibili per estrarne le proprietà (ad es. getFullYear() per ottenere l'anno a 4 cifre).

Di seguito sono riportati alcuni metodi di data comuni.

Prendi l'anno in corso

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

Ottieni il mese corrente

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

Si prega di notare che 0 = gennaio. Questo perché i mesi vanno da 0 a 11 , quindi è spesso preferibile aggiungere +1 all'indice.

Prendi il giorno corrente

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

Ottieni l'ora corrente

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

Ricevi i minuti correnti

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

Ottieni i secondi correnti

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

Ottieni gli attuali millisecondi

Per ottenere i millisecondi (compresi tra 0 e 999) di un'istanza di un oggetto Date , utilizzare il metodo getMilliseconds .

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

Converti l'ora e la data correnti in una stringa leggibile dall'uomo

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

Il metodo statico Date.now() restituisce il numero di millisecondi che sono trascorsi dal 1 gennaio 1970 alle 00:00:00 UTC. Per ottenere il numero di millisecondi che sono trascorsi da quel momento utilizzando un'istanza di un oggetto Date , utilizzare il suo metodo 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());

Crea un nuovo oggetto Date

Per creare un nuovo oggetto Date usa il costruttore Date() :

• senza argomenti

  Date() crea un'istanza Date contenente l'ora corrente (fino a millisecondi) e la data.

• con un argomento intero

  Date(m) crea un'istanza di Date contenente l'ora e la data corrispondenti all'ora Epoch (1 gennaio 1970 UTC) più m millisecondi. Esempio: new Date(749019369738) indica la data Sun, 26 Set 1993 04:56:09 GMT .

• con un argomento stringa

  Date(dateString) restituisce l'oggetto Date che risulta dopo l'analisi di dateString con Date.parse .

• con due o più argomenti interi

  Date(i1, i2, i3, i4, i5, i6) legge gli argomenti come anno, mese, giorno, ore, minuti, secondi, millisecondi e crea un'istanza dell'oggetto Date corrispondente. Si noti che il mese è 0-indicizzato in JavaScript, quindi 0 significa gennaio e 11 significa dicembre. Esempio: new Date(2017, 5, 1) dà il 1 ° giugno 2017 .

Esplorando le date

Si noti che questi esempi sono stati generati su un browser nel fuso orario centrale degli Stati Uniti, durante l'ora legale, come evidenziato dal codice. Laddove il confronto con UTC è stato istruttivo, Date.prototype.toISOString() stato utilizzato per mostrare la data e l'ora in UTC (la Z nella stringa formattata indica 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

Converti in JSON

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

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

Creazione di una data da UTC

Per impostazione predefinita, un oggetto Date viene creato come ora locale. Ciò non è sempre auspicabile, ad esempio quando si comunica una data tra un server e un client che non risiedono nello stesso fuso orario. In questo scenario, non ci si deve preoccupare affatto dei fusi orari finché non è necessario visualizzare la data nell'ora locale, se è addirittura necessario.

Il problema

In questo problema vogliamo comunicare una data specifica (giorno, mese, anno) con qualcuno in un fuso orario diverso. La prima implementazione utilizza in modo ingenuo le ore locali, il che si traduce in risultati errati. La seconda implementazione utilizza le date UTC per evitare i fusi orari in cui non sono necessari.

Approccio ingenuo con risultati WRONG

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

Esempio di output: 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()));

Esempio di produzione: Foo was born on: Fri Dec 31 1999

E così, Bar avrebbe sempre creduto che Foo fosse nato l'ultimo giorno del 1999.

Approccio corretto

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

Esempio di output: 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()));

Esempio di output: Foo was born on: Sat Jan 1 2000

Creazione di una data da UTC

Se si desidera creare un oggetto Date basato su UTC o GMT, è possibile utilizzare il Date.UTC(...) . Utilizza gli stessi argomenti del costruttore di Date più lungo. Questo metodo restituirà un numero che rappresenta il tempo trascorso dal 1 ° gennaio 1970 alle 00:00:00 UTC.

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

Uscita campione: 949320000000

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

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

Non sorprende che la differenza tra ora UTC e ora locale sia, in effetti, l'offset del fuso orario convertito in millisecondi.

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

Esempio di output: true

Modifica di un oggetto Date

Tutti i modificatori di oggetti Date , come setDate(...) e setFullYear(...) hanno un equivalente, accetta un argomento in ora UTC piuttosto che in ora locale.

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

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

Gli altri modificatori specifici per UTC sono .setUTCMonth() , .setUTCDate() (per il giorno del mese), .setUTCMinutes() , .setUTCSeconds() e .setUTCMilliseconds() .

Evitare ambiguità con getTime () e setTime ()

Laddove i metodi di cui sopra sono necessari per distinguere tra ambiguità nelle date, di solito è più semplice comunicare una data come la quantità di tempo trascorso dal 1 ° gennaio 1970 alle 00:00:00 UTC. Questo singolo numero rappresenta un singolo punto nel tempo e può essere convertito all'ora locale ogni volta che è necessario.

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

Esempio di output: 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);

Uscita di esempio:

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

Converti in un formato stringa

Converti in stringa

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

Restituisce: "Ven Apr 15 2016 07:48:48 GMT-0400 (Eastern Daylight Time)"

Converti in stringa del tempo

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

Restituisce: "07:48:48 GMT-0400 (ora legale orientale)"

Converti in data

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

Resi: "Gio 14 Apr 2016"

Converti in stringa UTC

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

Restituzioni: "Ven, 15 Apr 2016 11:48:48 GMT"

Converti in una stringa ISO

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

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

Converti in stringa GMT

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

Resi: "Gio, 14 Apr 2016 23:49:08 GMT"

Questa funzione è stata contrassegnata come deprecata, quindi alcuni browser potrebbero non supportarla in futuro. Si consiglia di utilizzare toUTCString () invece.

Converti in stringa di data locale

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

Resi: "14/04/2016"

Questa funzione restituisce una stringa di data sensibile alle impostazioni internazionali in base alla posizione dell'utente per impostazione predefinita.

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

può essere usato per fornire localizzazioni specifiche ma è specifica per l'implementazione del browser. Per esempio,

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

tenterebbe di stampare la stringa nella locale cinese usando l'inglese degli Stati Uniti come riserva. Il parametro options può essere utilizzato per fornire una formattazione specifica. Per esempio:

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

risulterebbe in

"Giovedì 14 aprile 2016".

Vedi l'MDN per maggiori dettagli.

Incrementa un oggetto data

Per incrementare gli oggetti data in Javascript, di solito possiamo fare questo:

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)

È possibile utilizzare setDate per modificare la data in un giorno del mese successivo utilizzando un valore maggiore del numero di giorni nel mese corrente:

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)

Lo stesso vale per altri metodi come getHours (), getMonth (), ecc.

Aggiunta di giorni lavorativi

Se si desidera aggiungere giorni di lavoro (in questo caso presumo dal lunedì al venerdì) è possibile utilizzare la funzione setDate anche se è necessario un po 'di logica in più per tenere conto dei fine settimana (ovviamente questo non terrà conto delle festività nazionali) -

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

Ottieni il numero di millisecondi trascorsi dal 1 gennaio 1970 alle 00:00:00 UTC

Il metodo statico Date.now restituisce il numero di millisecondi che sono trascorsi dal 1 gennaio 1970 alle 00:00:00 UTC. Per ottenere il numero di millisecondi che sono trascorsi da quel momento utilizzando un'istanza di un oggetto Date , utilizzare il suo metodo 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());

Formattazione di una data JavaScript

Formattazione di una data JavaScript nei browser moderni

Nei browser moderni (*), Date.prototype.toLocaleDateString() consente di definire la formattazione di una Date in modo conveniente.

Richiede il seguente formato:

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

Il parametro locales deve essere una stringa con un tag di linguaggio BCP 47 o una matrice di tali stringhe.

Il parametro options dovrebbe essere un oggetto con alcune o tutte le seguenti proprietà:

• localeMatcher : i possibili valori sono "lookup" e "best fit" ; il valore predefinito è "best fit"
• timeZone : l'unica implementazione del valore che deve riconoscere è "UTC" ; il valore predefinito è il fuso orario predefinito del runtime
• hour12 : i possibili valori sono true e false ; l'impostazione predefinita dipende dalle impostazioni internazionali
• formatMatcher : i possibili valori sono "basic" e "best fit" ; il valore predefinito è "best fit"
• giorno della settimana : i valori possibili sono "narrow" , "short" e "long"
• era : i valori possibili sono "narrow" , "short" e "long"
• anno : i valori possibili sono "numeric" e "2-digit"
• mese : i valori possibili sono "numeric" , "2-digit" , "narrow" , "short" e "long"
• giorno : i valori possibili sono "numeric" e "2-digit"
• ora : i valori possibili sono "numeric" e "2-digit"
• minuto : i valori possibili sono "numeric" e "2-digit"
• secondo : i valori possibili sono "numeric" e "2-digit"
• timeZoneName : i valori possibili sono "short" e "long"

Come usare

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

Risultato se eseguito il 24 gennaio 2036:

'24 Jan 2036'

Andando personalizzato

Se Date.prototype.toLocaleDateString() non è abbastanza flessibile per soddisfare qualsiasi esigenza tu possa avere, potresti prendere in considerazione la creazione di un oggetto Date personalizzato che assomiglia a questo:

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

Se hai incluso quel codice ed eseguito il new DateObject() il 20 gennaio 2019, produrrebbe un oggetto con le seguenti proprietà:

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

Per ottenere una stringa formattata, potresti fare qualcosa del genere:

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

Ciò produrrebbe il seguente risultato:

20-01-2016

(*) Secondo MDN , "browser moderni" significa Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ e Safari nightly build