Nombres et dates

Les nombres en JavaScript sont implémentés comme des nombres sur 64 bits à précision double selon le format IEEE-754 qui est un standard pour la représentation des nombres flottants et qui permet d'avoir jusqu'à 16 chiffres significatifs. Le type numérique possède également trois valeurs spéciales symboliques : +Infinity, -Infinity et NaN (pour désigner une valeur qui n'est pas un nombre).

Le format IEEE-754 permet de représenter des valeurs entre ±2^−1022 et ±2^+1023, ce qui correspond à des valeurs entre ±10^−308 et ±10^+308 avec une précision sur 53 bits. Les nombres entiers compris sur l'intervalle ±2^53 − 1 peuvent être représentés exactement.

Le type BigInt est une addition récente à JavaScript qui permet de représenter de grands entiers. Toutefois, il n'est pas possible de mélanger les BigInt et les nombres (Number) dans les mêmes opérations et on ne peut pas utiliser l'objet Math avec les valeurs BigInt.

Voir également les types de données et structures JavaScript pour l'articulation des types primitifs en JavaScript.

Il est possible d'utiliser quatre types de littéraux numériques : décimal, binaire, octal et hexadécimal.

1234567980;
42;

// Attention à l'utilisation des zéros
// en début de nombre

0888; // 888 analysé en base décimale
0777; // en mode non-strict, analysé en base octale,
// ce qui correspond
// à 511 en base décimale

On voit ici que les littéraux numériques qui commencent par un zéro (0) et contiennent un chiffre strictement inférieur à 8 après ce 0 sont analysés comme étant exprimés en base octale.

Pour utiliser des nombres binaires, on utilise un littéral qui commence par un 0 suivi d'un b minuscule ou majuscule (0b ou 0B). Si les chiffres qui suivent ce préfixe ne sont pas des 0 ou des 1, une exception SyntaxError sera levée.

var FLT_BITSIGNE = 0b10000000000000000000000000000000; // 2147483648
var FLT_EXPOSANT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSE = 0b00000000011111111111111111111111; // 8388607

Pour utiliser des nombres en base octale, on utilisera un préfixe avec un 0. Si les nombres qui suivent ce 0 ne sont pas compris entre 0 et 7 (au sens strict), le nombre sera interprété comme un nombre décimal.

var n = 0755; // 493 en base 10
var m = 0644; // 420 en base 10

En mode strict, ECMAScript 5 interdit cette syntaxe octale. Cette syntaxe ne fait pas partie d'ECMAScript 5 mais est supportée par la majorité des navigateurs. Avec ECMAScript 2015 (ES6), il est possible de représenter un nombre en notation octale grâce au préfixe "0o" :

var a = 0o10; // Notation octale pour ES2015

Pour utiliser des nombres exprimés en base hexadécimale, on utilisera un préfixe avec un zéro suivi d'un x majuscule ou minuscule (0x ou 0X). Si les chiffres qui suivent ce préfixe ne sont pas 0123456789ABCDEF, cela provoquera une exception SyntaxError.

0xfffffffffffffffff; // 295147905179352830000
0x123456789abcdef; // 81985529216486900
0xa; // 10

L'objet Number possède certaines propriétés représentant les constantes numériques telles que : la valeur maximale représentable en JavaScript, une valeur spéciale pour dire que la valeur numérique n'est pas un nombre et l'infini. Ces valeurs ne peuvent pas être modifiées, on pourra les utiliser de la façon suivante :

var plusGrandNombre = Number.MAX_VALUE;
var plusPetitNombre = Number.MIN_VALUE;
var infini = Number.POSITIVE_INFINITY;
var infiniNégatif = Number.NEGATIVE_INFINITY;
var pasUnNombre = Number.NaN;

On utilisera toujours ces valeurs directement avec l'objet natif Number (et non pas avec les propriétés d'une instance d'un objet Number qu'on aurait créé).

Le tableau qui suit liste certaines des propriétés de Number.

Le prototype de Number fournit certaines méthodes pour exprimer les valeurs représentées par les objets Number dans différents formats. Le tableau suivant liste certaines de ces méthodes de Number.prototype.

L'objet natif Math possède des propriétés et des méthodes statiques pour représenter des constantes et des fonctions mathématiques. Ainsi, la propriété PI de l'objet Math représente la valeur de la constante $\pi$ (3.141...), on peut l'utiliser dans les applications avec :

Math.PI;

De la même façon, les fonctions mathématiques usuelles sont des méthodes de Math. On retrouve par exemple les fonctions trigonométriques, logarithmiques et exponentielles ainsi que d'autres fonctions. Si on souhaite utiliser la fonction sinus, on pourra écrire :

Math.sin(1.56);

Le tableau suivant liste les méthodes de l'objet Math.

À la différence des autres objets, on ne crée pas d'objet de type Math. Ses propriétés sont statiques, on les appelle donc toujours depuis l'objet Math.

JavaScript ne possède pas de type primitif pour représenter des dates. Cependant l'objet Date et ses méthodes permettent de manipuler des dates et des heures au sein d'une application. L'objet Date possède de nombreuses méthodes pour définir, modifier, obtenir des dates. Il ne possède pas de propriétés.

JavaScript gère les dates de façon similaire à Java. Les deux langages possèdent de nombreuses méthodes en commun et les deux langages stockent les dates selon les nombres de millisecondes écoulées depuis le premier janvier 1970 à 00h00:00.

L'objet Date permet de représenter des dates allant de -100 000 000 jours jusqu'à +100 000 000 jours par rapport au premier janvier 1970 UTC.

Pour créer un objet Date, on utilisera la syntaxe suivante :

var monObjetDate = new Date([paramètres]);

avec monObjetDate étant le nom de l'objet à créer, cela peut être un nouvel objet ou une propriété d'un objet existant.

Lorsqu'on appelle Date sans le mot-clé new, cela renvoie la date fournie sous la forme d'une chaîne de caractères.

Les paramètres qui peuvent être utilisés sont :

• Aucun paramètre : l'objet créé représentera la date et l'heure courante.
• Une chaîne de caractères représentant une date au format suivant : "jour, année heures:minutes:secondes". Par exemple var noël95 = new Date("December 25, 1995 13:30:00"). Si les valeurs pour les heures, minutes ou secondes sont absentes, elles vaudront 0 par défaut.
• Un ensemble de valeurs entières pour l'année, le mois et le jour : var noël95 = new Date(1995, 11, 25).
• Un ensemble de valeurs entières pour l'année, le mois, le jour, l'heure, les minutes et les secondes : var noël95 = new Date(1995, 11, 25, 9, 30, 0);.

Les méthodes de l'objet Date se répartissent en différentes catégories :

• celles utilisées pour définir et modifier les valeurs des objets Date (mutateurs).
• celles utilisées pour obtenir des informations à partir des objets Date (accesseurs).
• celles utilisées pour convertir les objets Date sous différents formats (souvent en chaînes de caractères).
• celles utilisées pour analyser et convertir des chaînes de caractères représentant des dates.

Avec les accesseurs et les mutateurs, il est possible d'obtenir ou de modifier séparément les secondes, les minutes, les heures, le jour du mois ou de la semaine, le mois et l'année. Il existe une méthode getDay qui renvoie le jour de la semaine mais il n'existe pas de méthode réciproque setDay car le jour de la semaine est automatiquement déterminé. Ces méthodes utilisent des entiers pour représenter les valeurs utilisées :

• Pour les secondes et les minutes : 0 à 59
• Pour les heures : 0 à 23
• Pour les jours : 0 (dimanche) à 6 (samedi)
• Pour les dates : 1 à 31 (jour du mois)
• Pour les mois : 0 (janvier) à 11 (décembre)
• Pour les années : les années à partir de 1900

Ainsi, si on définit la date suivante :

var noël95 = new Date("December 25, 1995");

noël95.getMonth() renverra 11, et noël95.getFullYear() renverra 1995.

Les méthodes getTime et setTime peuvent être utiles pour comparer des dates entre elles. La méthode getTime renvoie le nombre de millisecondes écoulées depuis le premier janvier 1970 à 00:00:00 pour l'objet Date.

Par exemple, les instructions suivantes affichent le nombre de jours qui restent pour l'année courante :

var aujourdhui = new Date();

// On définit le jour et le mois
var finAnnée = new Date(1995, 11, 31, 23, 59, 59, 999);

// On définit l'année avec l'année courante
finAnnée.setFullYear(aujourdhui.getFullYear());

// On calcule le nombre de millisecondes par jour
var msParJour = 24 * 60 * 60 * 1000;

// On renvoie le nombre de jours restants dans l'année
var joursRestants = (finAnnée.getTime() - aujourdhui.getTime()) / msParJour;

joursRestants = Math.round(joursRestants);

Cet exemple crée un objet Date nommé aujourdhui qui contient la date du jour. On crée ensuite un objet Date nommé finAnnée pour lequel on définit ensuite l'année avec l'année courante. Après, on calcule le nombre de millisecondes qui s'écoulent dans une journée. Enfin, on calcule le nombre de jours entre aujourdhui et finAnnée en utilisant getTime puis on arrondit le tout pour avoir un nombre de jours.

La méthode parse est utile lorsqu'on souhaite affecter des valeurs temporelles à partir de chaînes de caractères. Par exemple, dans le code qui suit, on utilise les méthodes parse et setTime pour affecter la valeur d'une date à un objet IPOdate :

var IPOdate = new Date();
IPOdate.setTime(Date.parse("Aug 9, 1995"));

Dans l'exemple qui suit, la fonction JSClock() renvoie le temps au format d'une horloge numérique représentant les heures sur 12 heures :

function JSClock() {
  var temps = new Date();
  var heures = temps.getHours();
  var minutes = temps.getMinutes();
  var secondes = temps.getSeconds();
  var calc = "" + (heures > 12) ? heures - 12 : heures);
  if (heures == 0)
    calc = "12";
  calc += ((minutes < 10) ? ":0" : ":") + minutes;
  calc += ((secondes < 10) ? ":0" : ":") + secondes;
  calc += (heures >= 12) ? " P.M." : " A.M.";
  return calc;
}

Pour commencer, la fonction JSClock crée un objet Date appelé temps qui représente la date et l'heure à l'instant où la fonction est exécutée. Ensuite, les méthodes getHours, getMinutes, et getSeconds sont appelées afin d'affecter les valeurs correspondantes à heures, minutes, et secondes.

Les quatre instructions suivantes permettent de construire une chaîne de caractères à partir de la valeur temporelle. La première instruction crée une variable calc et lui affecte une valeur avec une expression conditionnelle : si heures est supérieure à 12, on affichera (heures - 12), sinon on affichera l'heure sauf si c'est 0 auquel cas on affichera 12.

L'instruction qui suit concatène la valeur de minutes à calc. Si la valeur de minutes est inférieure à 10, l'expression conditionnelle ajoutera une chaîne avec un zéro pour que la valeur soit affichée avec deux chiffres. De la même façon, l'instruction qui suit concatène la valeur de calc avec les secondes.

Enfin, une expression conditionnelle est utilisée pour ajouter "P.M." à calc si heures vaut 12 ou plus, sinon ce sera la chaîne "A.M." qui sera ajoutée à la fin de calc.

• Précédent
• Suivant