Les conversions de types

La plupart du temps, les opérateurs et les fonctions convertissent automatiquement les valeurs qui leur sont attribuées dans le bon type.

Par exemple, alert convertit automatiquement toute valeur en chaîne de caractères pour l’afficher. Les opérations mathématiques convertissent les valeurs en nombres.

Il y a aussi des cas où nous devons convertir explicitement une valeur pour corriger les choses.

String Conversion

La conversion String se produit lorsque nous avons besoin de la forme chaîne de caractères d’une valeur.

Par exemple, alert(value) le fait pour afficher la valeur.

Nous pouvons également utiliser un appel de fonction String(value) pour ça :

let value = true;
alert(typeof value); // boolean

value = String(value); // maintenant la valeur est une chaîne de caractères "true"
alert(typeof value); // string

La conversion String est assez évidente. Un false devient "false", null devient "null" etc.

Numeric Conversion

La conversion numérique dans les fonctions et expressions mathématiques s’effectue automatiquement.

Par exemple, lorsque la division / est appliqué à des non-numéros :

alert( "6" / "2" ); // 3, les chaînes de caractères sont converties en nombres

Nous pouvons utiliser une fonction Number(value) pour convertir explicitement une valeur :

let str = "123";
alert(typeof str); // string

let num = Number(str); // devient un nombre 123

alert(typeof num); // nombre

Une conversion explicite est généralement requise lorsque nous lisons une valeur à partir d’une source basée sur des chaînes de caractères, par exemple un champ texte, mais qu’un nombre doit être entré.

Si la chaîne de caractères n’est pas un nombre valide, le résultat de cette conversion est NaN, par exemple :

let age = Number("une chaîne de caractères arbitraire au lieu d'un nombre");

alert(age); // NaN, la conversion a échoué

Règles de conversion numériques :

Exemples:

alert( Number("   123   ") ); // 123
alert( Number("123z") );      // NaN (erreur de lecture d'un nombre à "z")
alert( Number(true) );        // 1
alert( Number(false) );       // 0

Veuillez noter que null et undefined se comportent différemment ici : null devient un zéro, alors qu’undefined devient NaN.

La plupart des opérateurs mathématiques effectuent également une telle conversion, nous le verrons dans le chapitre suivant.

Boolean Conversion

La conversion booléenne est la plus simple.

Cela se produit dans les opérations logiques (plus tard, nous nous intéresserons aux tests de condition et à d’autres types de tests), mais nous pouvons également l’effectuer manuellement avec l’appel de Boolean(value).

La règle de conversion :

• Les valeurs qui sont intuitivement “vides”, comme 0, une chaîne de caractères vide, null, undefined NaN deviennent false.
• Les autres valeurs deviennent true.

Par exemple :

alert( Boolean(1) ); // true
alert( Boolean(0) ); // false

alert( Boolean("hello") ); // true
alert( Boolean("") ); // false

alert( Boolean("0") ); // true
alert( Boolean(" ") ); // espaces, également vrai (toute chaîne de caractères non vide est vraie)

Résumé

Les trois conversions de types les plus utilisées sont : to string, to number et to boolean.

La conversion en String – Se produit lorsque nous sortons quelque chose, peut être effectué avec String(value). La conversion en chaîne de caractères est généralement évidente pour les valeurs primitives.

La conversion en Number – Se produit dans les opérations mathématiques, peut être effectué avec Number(value).

La conversion vers number suit les règles suivantes :

La conversion en Boolean – Se produit dans des opérations logiques, ou peut être effectué avec Boolean(value).

La conversion vers boolean suit les règles suivantes :

La plupart de ces règles sont faciles à comprendre et à mémoriser. Les exceptions notables où les gens font généralement des erreurs sont :

• undefined est NaN en tant que number, non 0.
• "0" et les espaces dans les chaines de caractères comme " " sont “true” en booléen.

Les objets ne sont pas couverts ici, nous y reviendrons plus tard dans le chapitre Conversion d'objet en primitive qui est consacré exclusivement aux objets, après avoir appris plus de choses basiques sur JavaScript.