Conversion de types ECMAScript

L'un des caractéristiques les plus importantes de tous les langages de programmation est la capacité de conversion de type.

ECMAScript offre aux développeurs un grand nombre de méthodes de conversion de type simples.

La plupart des types possèdent des méthodes de conversion simples, ainsi que quelques méthodes globales pour des conversions plus complexes. Dans tous les cas, dans ECMAScript, la conversion de type est une opération brève et simple.

Conversion en chaîne

Ce qui est intéressant des valeurs primitives Boolean, numérique et chaîne de caractères en ECMAScript est qu'elles sont des pseudo-objets, ce qui signifie qu'elles possèdent réellement des propriétés et des méthodes.

Par exemple, pour obtenir la longueur d'une chaîne, vous pouvez utiliser le code suivant :

var sColor = "red";
alert(sColor.length); // Affiche "3"

Bien que "red" soit une chaîne de caractères de type primitif, elle possède toujours une propriété length utilisée pour stocker la taille de la chaîne.

En résumé, les trois types primitifs principaux (Boolean, numérique et chaîne de caractères) ont une méthode toString(), permettant de convertir leurs valeurs en chaînes de caractères.

Avis :Vous pourriez vous demander : "Les chaînes de caractères ont-elles également une méthode toString() ? Est-ce superflu ?" Oui, c'est effectivement le cas, car ECMAScript définit que tous les objets ont une méthode toString(), qu'ils soient des pseudo-objets ou des objets réels. Comme le type String appartient aux pseudo-objets, il possède donc nécessairement une méthode toString().

La méthode toString() du type Boolean affiche simplement "true" ou "false", le résultat est déterminé par la valeur de la variable :

var bFound = false;
alert(bFound.toString()); // Sortie "false"

La méthode toString() du type Number est très spéciale, elle a deux modes, à savoirMode par défautetMode de base。En utilisant le mode par défaut, la méthode toString() affiche simplement la valeur numérique correspondante (que ce soit un entier, un nombre à virgule flottante ou une représentation en exposant scientifique), comme suit :

var iNum1 = 10;
var iNum2 = 10.0;
alert(iNum1.toString()); // Sortie "10"
alert(iNum2.toString()); // Sortie "10"

Remarque :Dans le mode par défaut, peu importe la manière dont le nombre est déclaré au départ, la méthode toString() du type Number retourne toujours la représentation décimale du nombre. Par conséquent, les nombres déclarés sous forme de littéraux octaux ou hexadécimaux sont tous affichés sous forme décimale.

En utilisant le schéma de base de la méthode toString() du type Number, on peut utiliser desBaseAfficher un nombre, par exemple, la base binaire est 2, la base octale est 8, et la base hexadécimale est 16.

BaseC'est simplement une autre addition pour convertir en base, qui est le paramètre de la méthode toString() :

var iNum = 10;
alert(iNum.toString(2)); // Sortie "1010"
alert(iNum.toString(8)); // Sortie "12"
alert(iNum.toString(16)); // Sortie "A"

Dans l'exemple précédent, le nombre 10 a été affiché sous trois formes différentes : binaire, octal et hexadécimal. HTML utilise l'hexadécimal pour représenter chaque couleur, ce qui est très utile pour traiter les nombres en HTML.

Remarque :Appeler toString(10) sur un nombre est le même que appeler toString(), ils renvoient tous deux la forme décimale de ce nombre.

Voir :

Voir Manuel de référence JavaScriptDétails détaillés sur la méthode toString() :

Conversion en nombre

ECMAScript fournit deux méthodes pour convertir des valeurs primitives non numériques en nombres, à savoir parseInt() et parseFloat().

Comme vous pourriez l'imaginer, le premier convertit la valeur en entier, et le second en nombre à virgule flottante. Ces méthodes ne fonctionnent correctement que lorsqu'elles sont appelées sur des types String ; pour d'autres types, elles retournent NaN.

parseInt()

Avant de déterminer si une chaîne est une valeur numérique, parseInt() et parseFloat() analysent soigneusement la chaîne.

La méthode parseInt() examine d'abord le caractère à la position 0 pour déterminer s'il s'agit d'un chiffre valide ; s'il ne l'est pas, la méthode retourne NaN et ne continue pas d'autres opérations. Mais si le caractère est un chiffre valide, la méthode examine le caractère à la position 1 et procède de la même manière. Ce processus continue jusqu'à ce qu'un caractère non valide soit détecté, auquel cas parseInt() convertit la chaîne avant ce caractère en nombre.

Par exemple, si vous devez convertir la chaîne "12345red" en nombre, la méthode parseInt() retournera 12345, car dès qu'elle détecte le caractère r, elle arrêtera le processus de détection.

Les littéraux numériques contenus dans la chaîne de caractères sont correctement convertis en nombres, par exemple "0xA" est correctement converti en le nombre 10. Cependant, la chaîne "22.5" est convertie en 22, car pour un nombre entier, le point décimal est un caractère invalide.

Voici quelques exemples :

var iNum1 = parseInt("12345red"); // retourne 12345
var iNum1 = parseInt("0xA"); // retourne 10
var iNum1 = parseInt("56.9"); // retourne 56
var iNum1 = parseInt("red"); // retourne NaN

La méthode parseInt() a également un mode de base qui permet de convertir des chaînes de caractères en nombres binaires, octaux, hexadecimaux ou d'autres systèmes de numération. La base est spécifiée par le deuxième paramètre de la méthode parseInt(), donc pour解析十六进制值，il faut appeler la méthode parseInt() comme suit :

var iNum1 = parseInt("AF", 16); // retourne 175

Bien sûr, pour les nombres binaires, octaux, décimaux (mode par défaut) et autres systèmes de numération, vous pouvez appeler la méthode parseInt() ainsi :

var iNum1 = parseInt("10", 2); // retourne 2
var iNum2 = parseInt("10", 8); // retourne 8
var iNum3 = parseInt("10", 10); // retourne 10

Si un nombre décimal contient des zéros de tête, il est préférable d'utiliser le base 10 pour éviter d'obtenir une valeur octale par surprise. Par exemple :

var iNum1 = parseInt("010"); // retourne 8
var iNum2 = parseInt("010", 8); // retourne 8
var iNum3 = parseInt("010", 10); // retourne 10

Dans ce segment de code, les deux lignes de code convertissent la chaîne "010" en un nombre. La première ligne de code considère cette chaîne comme une valeur octale, et l'interprète de la même manière que la deuxième ligne de code (dclarant le base à 8). La dernière ligne de code dclarant le base à 10, donc iNum3 vaut finalement 10.

Voir

Voir Manuel de référence JavaScriptVoici des détails sur la méthode parseInt() :parseInt().

parseFloat()

La méthode parseFloat() traite de la même manière que la méthode parseInt(), en regardant chaque caractère à partir de la position 0 jusqu'à ce qu'il trouve le premier caractère non valide, puis convertit la chaîne avant ce caractère en nombre.

Cependant, pour cette méthode, le premier point décimal est un caractère valide. S'il y a deux points décimaux, le second point décimal sera considéré comme invalide. parseFloat() convertira les caractères avant ce point décimal en nombre. Cela signifie que la chaîne "11.22.33" sera interprétée comme 11.22.

Une autre différence de l'utilisation de la méthode parseFloat() est que la chaîne doit être représentée sous forme décimale pour le nombre en virgule flottante, et non en octal ou en hexadécimal. Cette méthode ignore les zéros de tête, donc le nombre octal 0102 sera interprété comme 102. Pour le nombre hexadécimal 0xA, cette méthode retournera NaN, car dans les nombres en virgule flottante, x n'est pas un caractère valide).Remarque :Selon les tests, l'implémentation spécifique du navigateur retourne 0 plutôt que NaN).

De plus, la méthode parseFloat() n'a pas de modèle de base.

Voici quelques exemples d'utilisation de la méthode parseFloat() :

var fNum1 = parseFloat("12345red"); // retourne 12345
var fNum2 = parseFloat("0xA"); // retourne NaN
var fNum3 = parseFloat("11.2"); // retourne 11.2
var fNum4 = parseFloat("11.22.33"); // retourne 11.22
var fNum5 = parseFloat("0102"); // retourne 102
var fNum1 = parseFloat("red"); // retourne NaN

Essayez-le vous-même

Voir

Voir Manuel de référence JavaScriptVoici des détails sur la méthode parseFloat() :parseFloat().

Conversion de type forcee

Vous pouvez également utiliserConversion de type forcee (type casting)Pour traiter le type des valeurs à convertir. L'utilisation de la conversion de type forcee permet d'accéder à des valeurs spécifiques, même si elles sont de types différents.

Note de l'auteur :Le terme "cast" signifie "forgé", ce qui correspond bien à l'idée de "conversion de type forcee".

Les trois types de conversion de type disponibles dans ECMAScript sont les suivants :

  • Boolean(value) - Convertit la valeur donnée en type Boolean;
  • Number(value) - Convertit la valeur donnée en nombre (peut être un entier ou un nombre à virgule flottante);
  • String(value) - Convertit la valeur donnée en chaîne de caractères;

En utilisant l'une de ces trois fonctions pour convertir une valeur, une nouvelle valeur est créée et stockée, qui contient la valeur directement convertie à partir de la valeur originale. Cela peut entraîner des conséquences imprévues.

La fonction Boolean()

Lorsque la valeur à convertir est une chaîne de caractères d'au moins un caractère, un nombre non nul ou un objet, la fonction Boolean() renvoie true. Si la valeur est une chaîne vide, un nombre 0, undefined ou null, elle renvoie false.

Vous pouvez tester la conversion de type forcee de Boolean avec le code suivant :

var b1 = Boolean(""); //false - chaîne vide
var b2 = Boolean("hello"); //true - chaîne non vide
var b1 = Boolean(50); //true - nombre non nul
var b1 = Boolean(null); //false - null
var b1 = Boolean(0); //false - zéro
var b1 = Boolean(new object()); //true - objet

La fonction Number()

La conversion de type forcee de la fonction Number() est similaire aux méthodes parseInt() et parseFloat(), mais elle convertit la valeur entière, pas une partie de la valeur.

Rappelez-vous, les méthodes parseInt() et parseFloat() ne convertissent que la chaîne de caractères avant le premier caractère invalide, donc "1.2.3" sera converti en "1" et "1.2" respectivement.

En utilisant Number() pour la conversion de type强制性, "1.2.3" retournera NaN, car la valeur de chaîne entière ne peut pas être convertie en nombre. Si la valeur de chaîne peut être complètement convertie, Number() déterminera s'il faut appeler la méthode parseInt() ou parseFloat().

Le tableau suivant explique ce qui se passe lorsque l'on appelle la méthode Number() pour différents types de valeurs :

Utilisation Résultat
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number("1.2") 1.2
Number("12") 12
Number("1.2.3") NaN
Number(new object()) NaN
Number(50) 50

Fonction String()

La dernière méthode de conversion de type强制性 String() est la plus simple, car elle peut convertir n'importe quelle valeur en chaîne.

Pour effectuer cette conversion de type强制性, il suffit d'appeler la méthode toString() passée en tant que paramètre, c'est-à-dire de convertir 12 en "12", de convertir true en "true", de convertir false en "false", etc.

La seule différence entre la conversion de type强制性 en chaîne et l'appel de la méthode toString() est que la conversion de type强制性 de valeurs null et undefined peut générer une chaîne sans provoquer d'erreur :

var s1 = String(null); // "null"
var oNull = null;
var s2 = oNull.toString(); // Cela provoquera une erreur

Lors du traitement des langages de type faible tels que ECMAScript, la conversion de type强制性 est très utile, mais il faut s'assurer que les valeurs utilisées sont correctes.