JavaScript
Rendez-vous amoureux

Syntaxe

• nouvelle date ();
• nouvelle date (valeur);
• nouvelle date (dateAsString);
• new Date (année, mois [, jour [, heure [, minute [, seconde [, milliseconde]]]]]);

Paramètres

Obtenir l'heure et la date actuelles

Utilisez new Date() pour générer un nouvel objet Date contenant la date et l'heure actuelles.

Notez que Date() appelé sans arguments est équivalent à new Date(Date.now()) .

Une fois que vous avez un objet date, vous pouvez appliquer l'une des méthodes disponibles pour extraire ses propriétés (par exemple, getFullYear() pour obtenir l'année à 4 chiffres).

Vous trouverez ci-dessous des méthodes de datation communes.

Obtenez l'année en cours

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

Obtenez le mois en cours

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

Veuillez noter que 0 = janvier. C'est parce que les mois vont de 0 à 11 , il est donc souvent souhaitable d'ajouter +1 à l'index.

Obtenez le jour actuel

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

Obtenez l'heure actuelle

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

Obtenez les minutes actuelles

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

Obtenez les secondes actuelles

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

Récupère les millisecondes actuelles

Pour obtenir les millisecondes (comprises entre 0 et 999) d'une instance d'un objet Date , utilisez sa méthode getMilliseconds .

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

Convertir l'heure et la date actuelles en une chaîne lisible par l'homme

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

La méthode statique Date.now() renvoie le nombre de millisecondes écoulées depuis le 1er janvier 1970 00:00:00 UTC. Pour obtenir le nombre de millisecondes écoulées depuis ce temps en utilisant une instance d'un objet Date , utilisez sa méthode 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());

Créer un nouvel objet Date

Pour créer un nouvel objet Date , utilisez le constructeur Date() :

• sans arguments

  Date() crée une instance Date contenant l'heure actuelle (jusqu'à millisecondes) et la date.

• avec un argument entier

  Date(m) crée une instance Date contenant l'heure et la date correspondant à l'heure Epoch (1er janvier, 1970 UTC) plus m millisecondes. Exemple: new Date(749019369738) donne la date Sun, 26 Sep 1993 04:56:09 GMT .

• avec un argument de chaîne

  Date(dateString) renvoie l'objet Date résultant de l'analyse syntaxique de dateString avec Date.parse .

• avec deux ou plusieurs arguments entiers

  Date(i1, i2, i3, i4, i5, i6) lit les arguments en année, mois, jour, heures, minutes, secondes, millisecondes et instancie l'objet Date correspondant. Notez que le mois est indexé en JavaScript, 0 signifie janvier et 11 signifie décembre. Exemple: new Date(2017, 5, 1) donne le 1er juin 2017 .

Explorer des dates

Notez que ces exemples ont été générés sur un navigateur dans le fuseau horaire central des États-Unis, pendant l'heure avancée, comme en témoigne le code. Lorsque la comparaison avec UTC était instructive, Date.prototype.toISOString() était utilisé pour afficher la date et l'heure en UTC (le Z dans la chaîne formatée indique 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

Convertir en JSON

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

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

Création d'une date depuis UTC

Par défaut, un objet Date est créé en tant qu'heure locale. Ce n'est pas toujours souhaitable, par exemple lors de la communication d'une date entre un serveur et un client qui ne réside pas dans le même fuseau horaire. Dans ce scénario, on ne veut pas du tout s’inquiéter des fuseaux horaires tant que la date ne doit pas être affichée à l’heure locale, s’il est même nécessaire.

Le problème

Dans ce problème, nous souhaitons communiquer une date spécifique (jour, mois, année) avec une personne dans un fuseau horaire différent. La première implémentation utilise naïvement les heures locales, ce qui entraîne des résultats incorrects. La deuxième implémentation utilise des dates UTC pour éviter les fuseaux horaires là où ils ne sont pas nécessaires.

Approche naïve avec des résultats incorrects

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

Exemple de sortie: 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()));

Exemple de production: Foo was born on: Fri Dec 31 1999

Et ainsi, Bar croit toujours que Foo est né le dernier jour de 1999.

Approche correcte

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

Exemple de sortie: 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()));

Exemple de sortie: Foo was born on: Sat Jan 1 2000

Création d'une date depuis UTC

Si l'on veut créer un objet Date basé sur UTC ou GMT, la Date.UTC(...) peut être utilisée. Il utilise les mêmes arguments que le constructeur de Date le plus long. Cette méthode renverra un nombre représentant le temps écoulé depuis le 1er janvier 1970 à 00:00:00 UTC.

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

Sortie de l'échantillon: 949320000000

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

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

Sans surprise, la différence entre l'heure UTC et l'heure locale est en fait le décalage du fuseau horaire converti en millisecondes.

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

Exemple de sortie: true

Changer un objet Date

Tous les modificateurs d'objet Date , tels que setDate(...) et setFullYear(...) ont un équivalent qui prend un argument à l'heure UTC plutôt qu'à l'heure locale.

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

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

Les autres modificateurs spécifiques à UTC sont .setUTCMonth() , .setUTCDate() (pour le jour du mois), .setUTCMinutes() , .setUTCSeconds() et .setUTCMilliseconds() .

Éviter toute ambiguïté avec getTime () et setTime ()

Lorsque les méthodes ci-dessus sont nécessaires pour différencier les ambiguïtés dans les dates, il est généralement plus facile de communiquer une date comme étant le temps écoulé depuis le 1er janvier 1970 à 00:00:00 UTC. Ce numéro unique représente un seul point dans le temps et peut être converti en heure locale si nécessaire.

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

Exemple de sortie: 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);

Sortie de l'échantillon:

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

Convertir en un format de chaîne

Convertir en chaîne

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

Retours: "Ven Apr 15 2016 07:48:48 GMT-0400 (heure avancée de l'Est)"

Convertir en chaîne de temps

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

Retours: "07:48:48 GMT-0400 (heure avancée de l'Est)"

Convertir en chaîne de date

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

Retours: "jeu 14 avril 2016"

Convertir en chaîne UTC

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

Retours: "Ven 15 Avr 2016 11:48:48 GMT"

Convertir en chaîne ISO

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

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

Convertir en chaîne GMT

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

Retours: "jeu. 14 avril 2016 23:49:08 GMT"

Cette fonction a été marquée comme obsolète, de sorte que certains navigateurs peuvent ne plus le prendre en charge à l'avenir. Il est suggéré d'utiliser toUTCString () à la place.

Convertir en date locale

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

Retours: "14/04/2016"

Cette fonction renvoie une chaîne de date sensible aux paramètres régionaux en fonction de l'emplacement de l'utilisateur par défaut.

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

peut être utilisé pour fournir des paramètres régionaux spécifiques mais est spécifique à l'implémentation du navigateur. Par exemple,

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

tenterait d'imprimer la chaîne dans la langue chinoise en utilisant l'anglais des États-Unis comme solution de rechange. Le paramètre options peut être utilisé pour fournir un formatage spécifique. Par exemple:

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

aboutirait à

"Jeudi 14 avril 2016".

Voir le MDN pour plus de détails.

Incrémenter un objet date

Pour incrémenter des objets de date en Javascript, nous pouvons généralement le faire:

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)

Il est possible d'utiliser setDate pour modifier la date en un jour du mois suivant en utilisant une valeur supérieure au nombre de jours du mois en cours -

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)

La même chose s'applique à d'autres méthodes telles que getHours (), getMonth (), etc.

Ajouter des journées de travail

Si vous souhaitez ajouter des jours de travail (dans ce cas, je suppose que lundi-vendredi), vous pouvez utiliser la fonction setDate bien que vous ayez besoin d'un peu de logique supplémentaire pour prendre en compte les week-ends (cela ne tiendra évidemment pas compte des jours fériés)

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

Obtenir le nombre de millisecondes écoulées depuis le 1er janvier 1970 00:00:00 UTC

La méthode statique Date.now renvoie le nombre de millisecondes écoulées depuis le 1er janvier 1970 00:00:00 UTC. Pour obtenir le nombre de millisecondes écoulées depuis ce temps en utilisant une instance d'un objet Date , utilisez sa méthode 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());

Formatage d'une date JavaScript

Formater une date JavaScript dans les navigateurs modernes

Dans les navigateurs modernes (*), Date.prototype.toLocaleDateString() vous permet de définir le formatage d'une Date de manière pratique.

Il nécessite le format suivant:

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

Le paramètre locales doit être une chaîne avec une balise de langage BCP 47 ou un tableau de ces chaînes.

Le paramètre options doit être un objet avec certaines ou toutes les propriétés suivantes:

• localeMatcher : les valeurs possibles sont "lookup" et "best fit" ; la valeur par défaut est "best fit"
• timeZone : les seules implémentations de valeur doivent être "UTC" ; la valeur par défaut est le fuseau horaire par défaut de l'exécution
• hour12 : les valeurs possibles sont true et false ; la valeur par défaut dépend de la localisation
• formatMatcher : les valeurs possibles sont "basic" et "best fit" ; la valeur par défaut est "best fit"
• jour de la semaine : les valeurs possibles sont "narrow" , "short" et "long"
• era : les valeurs possibles sont "narrow" , "short" et "long"
• année : les valeurs possibles sont "numeric" et "2-digit"
• month : les valeurs possibles sont "numeric" , "2-digit" , "narrow" , "short" et "long"
• jour : les valeurs possibles sont "numeric" et "2-digit"
• heure : les valeurs possibles sont "numeric" et "2-digit"
• minute : les valeurs possibles sont "numeric" et "2-digit"
• seconde : les valeurs possibles sont "numeric" et "2-digit"
• timeZoneName : les valeurs possibles sont "short" & "long"

Comment utiliser

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

Sortie si exécutée le 24 janvier 2036:

'24 Jan 2036'

Aller à la coutume

Si Date.prototype.toLocaleDateString() n'est pas assez flexible pour répondre à vos besoins, vous pouvez envisager de créer un objet Date personnalisé qui ressemble à ceci:

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

Si vous avez inclus ce code et exécuté new DateObject() le 20 janvier 2019, il produirait un objet avec les propriétés suivantes:

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

Pour obtenir une chaîne formatée, vous pouvez faire quelque chose comme ceci:

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

Cela produirait la sortie suivante:

20-01-2016

(*) Selon le MDN , "navigateurs modernes" signifie Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ et Safari nightly build