La coercition de type et la conversion de type sont des concepts fondamentaux de la programmation qui impliquent la conversion de données d'un type à un autre. Dans les langages de programmation, les données sont classées en différents types, tels que les entiers, les chaînes, les nombres à virgule flottante et les booléens. La capacité de convertir ou de contraindre des données d'un type à un autre est essentielle pour effectuer des opérations, manipuler des données et assurer la compatibilité et la cohérence des données au sein d'un programme.

Type coercition :

La coercition de type fait référence à la conversion automatique des types de données qui se produit dans JavaScript lorsque différents types de données sont utilisés ensemble dans une opération. Par exemple, si un nombre et une chaîne sont additionnés, JavaScript convertira automatiquement le nombre en chaîne pour effectuer l'opération.

 const num = 5; const str = "3"; console.log(num + str); //output: "53"

Dans l'exemple ci-dessus, le nombre 5 est automatiquement converti en chaîne « 5 » afin qu'il puisse être concaténé avec la chaîne « 3 » pour donner la sortie « 53 ». Voici d'autres exemples de coercition de type :

• Utilisation des opérateurs == ou != pour la comparaison, qui effectuent une coercition de type avant de faire une comparaison
• L'utilisation de l'opérateur unaire plus ( + ) avant une valeur effectuera une conversion de type en nombre. Cependant, le signe + ne peut apparaître qu'une seule fois et ne doit pas être suivi d'un espace.

Par exemple :

 const x = "5"; const y = +x; console.log(typeof y); // output: number

On pense souvent que l'utilisation de l'opérateur unaire + au début d'une valeur en JavaScript est un raccourci pour la fonction Number . Cependant, ce n'est pas le cas. L'opérateur unaire + et la fonction Number utilisent le même algorithme pour convertir une chaîne en nombre, mais il existe des différences subtiles.

Par exemple, alors que + lancera une TypeError lors de la rencontre d'un BigInt , Number() renverra la valeur numérique d'un BigInt mais avec une possible perte de précision. La coercition se produit également si vous utilisez l'opérateur de négation unaire ( - ) avant une chaîne de la même manière.

• Utilisation de l'instruction if , qui contraindra une valeur à un booléen avant de faire une comparaison

• En utilisant le && , || et ?: opérateurs, qui contraindront la valeur à un booléen avant d'effectuer l'opération.

  
  

Coulée de type :

D'autre part, la conversion de type fait référence à la conversion explicite des types de données. Ceci est fait en utilisant des fonctions de casting telles que Number() , String() , Boolean() et Symbol()

 const str = '5'; const num = Number(str); console.log(num); //output: 5

Dans cet exemple, la variable num est de type number, mais nous l'avons explicitement convertie en chaîne à l'aide de la fonction String() . Examinons plusieurs fonctions de conversion de type en JavaScript, ainsi qu'un exemple de code pour illustrer leur utilisation :

• Number() : La fonction Number() est utilisée pour convertir une valeur non numérique en une valeur numérique. Par exemple, si vous souhaitez convertir une valeur de chaîne de « 10 » en un nombre, vous utiliserez la fonction Number() comme ceci :

 const x = "5"; const y = x+10 const z= Number(x)+10; console.log(y); // output: 510 console.log(z); // output: 15

• parseInt() : La fonction parseInt est utilisée pour convertir une valeur en entier. Il est différent de Number() et parseFloat() car il ignore toute valeur après la décimale. Par exemple:

 const intValue = parseInt("3.14"); console.log(floatValue); // Output: 3

• parseFloat() : La fonction parseFloat() est utilisée pour convertir une valeur de chaîne en un nombre à virgule flottante. Il est très similaire à Number() sauf dans certains cas. Voyons l'exemple ci-dessous pour voir comment parseFloat() se compare à parseInt() et Number() :

 console.log(parseInt('22.5')); // Output: 22 console.log(parseFloat('22.5')); // Output: 22.5 console.log(Number('22.5')); // Output: 22.5 console.log(parseInt('070')); // Output: 70 console.log(parseFloat('070')); // Output: 70 console.log(Number('070')); // Output: 70 console.log(parseInt('1234blue')); // Output: 1234 console.log(parseFloat('1234blue')); // Output: 1234 console.log(Number('1234blue')); // Output: NaN console.log(parseInt('0xFF')); // Output: 255 console.log(parseFloat('0xFF')); // Output: 0 console.log(Number('0xFF')); // Output: 255 console.log(parseInt("10 20 30")); // 10 console.log(parseFloat("10 20 30")); // 10 console.log(Number("10 20 30")); // NaN

• String() : La fonction String() est utilisée pour convertir une valeur non-chaîne en une valeur chaîne. Les exemples ci-dessous montrent comment vous pouvez utiliser la fonction String() pour convertir différents types de valeurs en chaîne :

 const num = 10; console.log(String(num)); // "10" const bool = true; console.log(String(bool)); // "true" const obj = {name: "John"}; console.log(String(obj)); // "[object Object]" const arr = [1, 2, 3]; console.log(String(arr)); // "1,2,3" const date = new Date(); console.log(String(date)); // "Sun Jan 29 2023 18:52:01 GMT+0000 (Coordinated Universal Time)"

• Boolean() : La fonction Boolean permet de convertir une valeur non booléenne en une valeur booléenne. Par exemple, si vous voulez convertir une valeur numérique de 0 en booléen, vous utiliserez Boolean() comme ceci :

 let value = 0; console.log(Boolean(value)); // false value = "hello"; console.log(Boolean(value)); // true value = undefined; console.log(Boolean(value)); // false value = {}; console.log(Boolean(value)); // true value = -1; console.log(Boolean(value)); // true

C'est tout, les amis. J'espère que cet article vous a aidé à comprendre les tenants et les aboutissants de la conversion de type en JavaScript. Vous avez maintenant une solide compréhension de la façon de convertir explicitement vos variables en différents types (casting de type) ainsi que de la manière dont Javascript le fait implicitement (conversion de type).

Continuez à pratiquer et à expérimenter ces fonctions pour les maîtriser. N'oubliez pas d'aimer, de partager, de suivre et de commenter toutes les questions que vous pourriez avoir. Bon codage !

Conseil de pro :

Utilisez la comparaison d'égalité stricte === au lieu de la comparaison d'égalité abstraite == . Évitez de vous fier à la coercition de type implicite de JavaScript, en particulier dans les opérations arithmétiques, et utilisez toujours la conversion de type si nécessaire.

Également publié ici.