Le système de datation

L'heure et la date sont gérées par un seul et même objet qui se nomme Date. Avant de l'étudier de fond en comble, nous allons d'abord comprendre comment fonctionne le système de datation en Javascript.

Introduction aux systèmes de datation

Nous, humains, lisons la date et l'heure de différentes manières, peu importe la façon dont cela est écrit, nous arrivons toujours à deviner de quelle date ou heure il s'agit. En revanche, un ordinateur, lui, possède une manière propre à son système pour lire ou écrire la date.

Généralement, cette dernière est représentée sous un seul et même nombre qui est, par exemple : 1301412748510. Vous avez ici, sous la forme d'un nombre assez long, l'heure et la date à laquelle nous avons écrit ces lignes.

Et ce nombre signifie quoi ?

Il s'agit en fait, en Javascript, du nombre de millisecondes écoulées depuis le 1er janvier 1970 à minuit. Cette manière d'enregistrer la date est très fortement inspirée du système d'horodatage utilisé par les systèmes Unix. La seule différence entre le système Unix et le système du Javascript, c'est que ce dernier stocke le nombre de millisecondes, tandis que le premier stocke le nombre de secondes. Dans les deux cas, ce nombre s'appelle un timestamp.

Au final, ce nombre ne nous sert vraiment qu'à peu de choses à nous, développeurs, car nous allons utiliser l'objet Date qui va s'occuper de faire tous les calculs nécessaires pour obtenir la date ou l'heure à partir de n'importe quel timestamp.

L'objet Date

L'objet Date nous fournit un grand nombre de méthodes pour lire ou écrire une date. Il y en a d'ailleurs tellement que nous n'allons en voir qu'une infime partie.

Le constructeur

Commençons par le constructeur ! Ce dernier prend en paramètre de nombreux arguments et s'utilise de différentes manières. Voici les quatre manières de l'utiliser :

new Date();

new Date(timestamp);

new Date(dateString);

new Date(année, mois, jour [, heure, minutes, secondes, millisecondes ]);

À chaque instanciation de l'objet Date, ce dernier enregistre soit la date actuelle si aucun paramètre n'est spécifié, soit une date que vous avez choisie. Les calculs effectués par les méthodes de notre objet instancié se feront à partir de la date enregistrée. Détaillons l'utilisation de notre constructeur :

La première ligne instancie un objet Date dont la date est fixée à celle de l'instant même de l'instanciation.
La deuxième ligne vous permet de spécifier le timestamp à utiliser pour notre instanciation.
La troisième ligne prend en paramètre une chaîne de caractères qui doit être interprétable par la méthode parse(), nous y reviendrons.
Enfin, la dernière ligne permet de spécifier manuellement chaque composant qui constitue une date, nous retrouvons donc en paramètres obligatoires : l'année, le mois et le jour. Les quatre derniers paramètres sont facultatifs (c'est pour cela que vous voyez des crochets, ils signifient que les paramètres sont facultatifs). Ils seront initialisés à 0 s'ils ne sont pas spécifiés, nous y retrouvons : les heures, les minutes, les secondes et les millisecondes.

Les méthodes statiques

L'objet Date possède deux méthodes statiques, mais nous n'allons aborder l'utilisation que de la méthode parse().

Vu le nom de cette méthode vous pouvez déjà plus ou moins deviner ce qu'elle permet de faire. Cette méthode prend en unique paramètre une chaîne de caractères représentant une date et renvoie le timestamp associé. Cependant, nous ne pouvons pas écrire n'importe quelle chaîne de caractères, il faut respecter une certaine syntaxe qui se présente de la manière suivante :

Sat, 04 May 1991 20:00:00 GMT+02:00

Cette date représente donc le samedi 4 mai 1991 à 20h pile avec un décalage de deux heures supplémentaires par rapport à l'horloge de Greenwich.

Il existe plusieurs manières d'écrire la date, cependant nous ne fournissons que celle-là, car les dérives sont nombreuses. Si vous voulez connaître toutes les syntaxes existantes, allez donc jeter un coup d’œil au document qui traite de la standardisation de cette syntaxe (la syntaxe est décrite à partir de la page 11).

Enfin, pour utiliser cette syntaxe avec notre méthode, rien de plus simple :

var timestamp = Date.parse('Sat, 04 May 1991 20:00:00 GMT+02:00');

alert(timestamp); // Affiche : 673380000000

Les méthodes des instances de l'objet Date

Étant donné que l'objet Date ne possède aucune propriété standard, nous allons directement nous intéresser à ses méthodes qui sont très nombreuses. Elles sont d'ailleurs tellement nombreuses (et similaires en terme d'utilisation) que nous n'allons en lister que quelques-unes (les plus utiles bien sûr) et en expliquer le fonctionnement de manière générale.

Commençons tout de suite par huit méthodes très simples qui fonctionnent toutes selon l'heure locale :

getFullYear() : renvoie l'année sur 4 chiffres ;
getMonth() : renvoie le mois (0 à 11) ;
getDate() : renvoie le jour du mois (1 à 31) ;
getDay() : renvoie le jour de la semaine (0 à 6, la semaine commence le dimanche) ;
getHours() : renvoie l'heure (0 à 23) ;
getMinutes() : renvoie les minutes (0 à 59) ;
getSeconds() : renvoie les secondes (0 à 59) ;
getMilliseconds() : renvoie les millisecondes (0 à 999).

Ces huit méthodes possèdent chacune une fonction homologue de type « set ». Par exemple, avec la méthode getDay() il existe aussi, pour le même objet Date, la méthode setDay() qui permet de définir le jour en le passant en paramètre.

Chacune de ces méthodes s'utilise d'une manière enfantine : vous instanciez un objet Date et il ne vous reste plus qu'à appeler les méthodes souhaitées :

var myDate = new Date('Sat, 04 May 1991 20:00:00 GMT+02:00');

alert(myDate.getMonth()); // Affiche : 4

alert(myDate.getDay()); // Affiche : 6

Deux autres méthodes pourront aussi vous êtres utiles :

La méthode getTime() renvoie le timestamp de la date de votre objet ;
La méthode setTime() vous permet de modifier la date de votre objet en lui passant en unique paramètre un timestamp.

Mise en pratique : calculer le temps d'exécution d'un script

Dans de nombreux langages de programmation, il peut parfois être intéressant de faire des tests sur la rapidité d'exécution de différents scripts. En Javascript, ces tests sont très simples à faire notamment grâce à la prise en charge native des millisecondes avec l'objet Date (les secondes sont rarement très intéressantes à connaître, car elles sont généralement à 0 vu la rapidité de la majorité des scripts).

Admettons que vous ayez une fonction slow() que vous soupçonnez d'être assez lente, vous allez vouloir vérifier sa vitesse d'exécution. Pour cela, rien de bien compliqué !

Commençons tout d'abord par exécuter notre fonction :

slow();

Comment allons-nous opérer maintenant ? Nous allons récupérer le timestamp avant l'exécution de la fonction puis après son exécution, il n'y aura ensuite plus qu'à soustraire le premier timestamp au deuxième et nous aurons notre temps d'exécution ! Allons-y :

var firstTimestamp = new Date().getTime(); // On obtient le timestamp avant l'exécution

slow(); // La fonction travaille…

var secondTimestamp = new Date().getTime(), // On récupère le timestamp après l'exécution

result = secondTimestamp - firstTimestamp; // On fait la soustraction

alert("Le temps d'exécution est de : " + result + " millisecondes.");

Créé avec HelpNDoc Personal Edition: Générateur d'aides CHM gratuit