La coercition de type et la conversion de type sont des concepts de programmation qui font référence au processus de conversion d'un type de données en un autre.

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 afin que l'opération puisse être effectuée.

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

• 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 blanc. Par exemple :

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

• 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.

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()etBoolean()Symbol()

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

• Number(): La Number()fonction 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 Number()fonction comme ceci :

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

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

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

let num = 10;
console.log(String(num)); // "10"

let bool = true;
console.log(String(bool)); // "true"

let obj = {name: "John"};
console.log(String(obj)); // "[object Object]"

let arr = [1, 2, 3];
console.log(String(arr)); // "1,2,3"

let date = new Date();
console.log(String(date)); // "Sun Jan 29 2023 18:52:01 GMT+0000 (Coordinated Universal Time)"

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

Utilisez une comparaison d'égalité stricte ===au lieu d'une 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.