Types de base ECMAScript

ECMAScript possède 5 types primitifs (primitive type), à savoir Undefined, Null, Boolean, Number et String.

Opérateur typeof

L'opérateur typeof a un paramètre, à savoir la variable ou la valeur à vérifier. Par exemple :

var sTemp = "test string";
alert (typeof sTemp);    // Affiche "string"
alert (typeof 86);    // Affiche "number"

Appeler l'opérateur typeof sur une variable ou une valeur retournera l'une des valeurs suivantes :

  • undefined - Si la variable est de type Undefined
  • boolean - Si la variable est de type Boolean
  • number - Si la variable est de type Number
  • string - Si la variable est de type String
  • object - Si la variable est un type de référence ou un type Null

Remarque :Vous pourriez vous demander pourquoi l'opérateur typeof retourne "Object" pour la valeur null. En réalité, c'est une erreur dans l'implémentation initiale de JavaScript, puis elle a été poursuivie par ECMAScript. Actuellement, null est considéré comme un occupancy pour l'objet, ce qui explique ce paradoxe, mais techniquement, il reste une valeur primitive.

Type Undefined

Comme mentionné précédemment, le type Undefined ne possède qu'une seule valeur, à savoir undefined. Lorsque la variable déclarée n'est pas initialisée, sa valeur par défaut est undefined.

var oTemp;

La ligne de code précédente déclare la variable oTemp sans valeur initiale. Cette variable est attribuée la valeur undefined, c'est-à-dire le littéral du type undefined. On peut utiliser le code suivant pour tester si la valeur de cette variable est égale à undefined :

var oTemp;
alert(oTemp == undefined);

Ce code affiche "true", ce qui montre que ces deux valeurs sont effectivement égales. On peut également utiliser l'opérateur typeof pour afficher que la valeur de la variable est undefined :

var oTemp;
alert(typeof oTemp); // Affiche "undefined"

Astuce :La valeur undefined est différente de la valeur non définie. Cependant, l'opérateur typeof ne différencie pas vraiment ces deux valeurs. Considérez le code suivant :

var oTemp;
alert(typeof oTemp);  // Affiche "undefined"
alert(typeof oTemp2);  // Affiche "undefined"

Le code précédent affiche "undefined" pour les deux variables, même si seule la variable oTemp2 n'a pas été déclarée. Si d'autres opérateurs que typeof sont utilisés avec oTemp2, cela entraînera une erreur, car ces opérateurs ne peuvent être utilisés qu'avec des variables déclarées.

Par exemple, le code suivant provoquera une erreur :

var oTemp;
alert(oTemp2 == undefined);

Lorsque une fonction n'a pas de valeur de retour explicite, elle retourne également la valeur "undefined", comme montré ci-dessous :

function testFunc() {
}
alert(testFunc() == undefined);  // Affiche "true"

Type Null

Un autre type qui n'a qu'une seule valeur est Null, il a une valeur spécifique null, c'est-à-dire son littéral. La valeur undefined est dérivée de la valeur null, donc ECMAScript les définit comme égaux.

alert(null == undefined);  // Affiche "true"

Bien que ces deux valeurs soient égales, leur signification est différente. undefined est la valeur attribuée à une variable déclarée mais non initialisée, null est utilisé pour représenter un objet inexistant (un point a été fait sur cela simplement lors de la discussion de l'opérateur typeof). Si une fonction ou une méthode doit retourner un objet, null est généralement retourné lorsqu'on ne trouve pas cet objet.

Type Boolean

Le type Boolean est l'un des types les plus couramment utilisés dans ECMAScript. Il a deux valeurs : true et false (c'est-à-dire deux littéraux Boolean).

Même si false n'est pas égal à 0, 0 peut être converti en false si nécessaire, ce qui rend les deux sécurisés dans les expressions booléennes.

var bFound = true;
var bLost = false;

Type Number

Le type le plus spécialisé défini dans ECMA-262 est le type Number. Ce type peut représenter à la fois des entiers de 32 bits et des nombres flottants de 64 bits.

Tous les nombres saisis directement (plutôt que ceux accessibles à partir d'une autre variable) sont considérés comme des littéraux de type Number. Par exemple, le code suivant déclare une variable contenant une valeur entière, définie par le littéral 86 :

var iNum = 86;

Nombres octaux et hexadécimaux

Les entiers peuvent également être représentés sous forme de littéraux octaux (de base 8) ou hexadécimaux (de base 16). Un littéral octal doit commencer par 0, et les chiffres suivants peuvent être n'importe quel chiffre octal (de 0 à 7), comme le montre le code suivant :

var iNum = 070;  //070 équivaut à 56 en décimal

Pour créer un littéral hexadécimal, le premier chiffre doit être 0, suivi de la lettre x, puis de nombres hexadécimaux arbitraires (de 0 à 9 et de A à F). Ces lettres peuvent être en majuscules ou en minuscules. Par exemple :

var iNum = 0x1f;  //0x1f équivaut à 31 en décimal
var iNum = 0xAB;  //0xAB équivaut à 171 en décimal

Astuce :Bien que tous les entiers puissent être représentés sous forme de littéraux octaux ou hexadécimaux, tous les résultats des opérations mathématiques sont des résultats décimaux.

Nombre flottant

Pour définir une valeur flottante, il est nécessaire d'inclure un point décimal et un chiffre après le point décimal (par exemple, utiliser 1.0 plutôt que 1). Cela est considéré comme un littéral flottant. Par exemple :

var fNum = 5.0;

Un des points intéressants des littéraux flottants est que, avant de les utiliser dans un calcul, ce qui est véritablement stocké est une chaîne de caractères.

Système de notation scientifique

Pour des nombres très grands ou très petits, on peut représenter des nombres à virgule flottante en utilisant le système de notation scientifique, et représenter un nombre sous forme de nombre (y compris les nombres décimaux) suivi de e (ou E), puis d'un multiple de 10. Par exemple :

var fNum = 5.618e7

Ce symbole représente le nombre 56180000. En transformant le système de notation scientifique en expression calculable, on obtient cette valeur : 5.618 x 107。

On peut également représenter des nombres très petits en utilisant le système de notation scientifique, par exemple, 0.00000000000000008 peut être représenté par 8-e17(Ici, 10 est élevé au -17e pouvoir, ce qui signifie qu'il doit être divisé par 10 17 fois). ECMAScript convertit par défaut les nombres flottants avec 6 ou plus de zéros avant la virgule en notation scientifique.

Astuce :Les valeurs flottantes peuvent également être stockées sous forme de 64 bits IEEE 754, ce qui signifie que la valeur décimale peut avoir jusqu'à 17 décimales. Les valeurs après 17 décimales sont coupées, ce qui entraîne des erreurs mathématiques mineures.

Valeurs spéciales Number

Plusieurs valeurs spéciales sont également définies comme type Number. Les deux premiers sont Number.MAX_VALUE et Number.MIN_VALUE, qui définissent les extrémités extérieures de l'ensemble des valeurs Number. Tous les nombres ECMAScript doivent se situer entre ces deux valeurs. Cependant, les résultats de calcul peuvent ne pas tomber entre ces deux valeurs.

Lorsque le nombre calculé dépasse Number.MAX_VALUE, il est assigné la valeur Number.POSITIVE_INFINITY, ce qui signifie qu'il n'y a plus de valeur numérique. De même, les calculs générant des valeurs inférieures à Number.MIN_VALUE sont assignés la valeur Number.NEGATIVE_INFINITY, ce qui signifie également qu'il n'y a plus de valeur numérique. Si le calcul renvoie une valeur infinie, le résultat généré ne peut plus être utilisé dans d'autres calculs.

En réalité, il existe des valeurs spéciales pour l'infini, comme vous l'avez deviné, c'est-à-dire Infinity. La valeur de Number.POSITIVE_INFINITY est Infinity. La valeur de Number.NEGATIVE_INFINITY est -Infinity.

Les nombres infinis peuvent être positifs ou négatifs, donc une méthode peut être utilisée pour déterminer si un nombre est fini (au lieu de tester chaque nombre infini individuellement). La méthode isFinite() peut être appelée sur n'importe quel nombre pour s'assurer qu'il n'est pas infini. Par exemple :

var iResult = iNum * some_really_large_number;
if (isFinite(iResult)) {
    alert("finite");
}
else {
    alert("infinite");
}

La dernière valeur spéciale est NaN, ce qui signifie "Not a Number" (non un nombre). NaN est une valeur spéciale curieuse. En règle générale, ce type de situation se produit lorsque la conversion de type (String, Boolean, etc.) échoue. Par exemple, la conversion du mot "blue" en nombre échouera car il n'existe pas de nombre équivalent. Comme l'infini, NaN ne peut pas être utilisé dans les calculs arithmétiques. Une autre particularité de NaN est qu'il ne s'égalise pas à lui-même, ce qui signifie que le code suivant renverra false :

alert(NaN == NaN);  // Affiche "false"

Pour cette raison, il n'est pas recommandé d'utiliser la valeur NaN elle-même. La fonction isNaN() fait un très bon travail :

alert(isNaN("blue"));  // Affiche "true"
alert(isNaN("666"));  // Affiche "false"

Type String

L'unique caractéristique du type String est qu'il est le seul type primitif sans taille fixe. On peut utiliser une chaîne pour stocker 0 ou plusieurs caractères Unicode, représentés par des entiers sur 16 bits (Unicode est un ensemble de caractères internationaux, qui sera discuté plus loin dans ce tutoriel).

Chaque caractère dans une chaîne a une position spécifique, le premier caractère commence à la position 0, le deuxième caractère à la position 1, et ainsi de suite. Cela signifie que la position du dernier caractère dans une chaîne est toujours la longueur de la chaîne moins 1 :

La longueur de la chaîne et la position des caractères

Les littéraux de chaîne de caractères sont déclarés par des guillemets doubles (" ) ou des guillemets simples ( ' ). Java utilise des guillemets doubles pour déclarer des chaînes de caractères et des guillemets simples pour déclarer des caractères. Mais comme ECMAScript n'a pas de type de caractères, on peut utiliser l'une ou l'autre de ces deux notations. Par exemple, les deux lignes de code suivantes sont valides :

var sColor1 = "red";
var sColor2 = 'red';

Le type String inclut également plusieurs littéraux de caractères, les développeurs Java, C et Perl devraient être très familiers avec eux.

Voici une liste des littéraux de caractères ECMAScript :

littéral signification
\n retour chariot
\t tabulation
\b espace
\r retour chariot
\f retour à la ligne
\\\ barre oblique inversée
\' guillemets simples
\" guillemets doubles
\0nnn code octal nnn représente le caractère (n est un nombre octal entre 0 et 7
\xnn code hexadécimal nn représente le caractère (n est un nombre hexadécimal entre 0 et F
\unnnn code hexadécimal nnnn représente le caractère Unicode (n est un nombre hexadécimal entre 0 et F