Le typage dynamique de JavaScript signifie que votre code peut être un peu plus simple, mais il est toujours possible de faire des erreurs. Pour les éviter, il est utile de savoir comment JavaScript résout des valeurs de types différents, afin de les comparer.
Comprendre la conversion de type et la coercition en JavaScript est crucial pour écrire des programmes fiables et efficaces. Chaque concept a des cas d’utilisation spécifiques et des bonnes pratiques qui peuvent affecter le comportement de votre code.
Pourquoi la conversion de type et la coercition se produisent-elles en JavaScript ?
Le langage JavaScript est typé dynamiquement. Cela signifie que, contrairement aux langages à typage statique, JavaScript n’exige pas que vous définissiez explicitement le type de données d’une variable avant de l’utiliser. Au lieu de cela, JavaScript détermine le type au moment de l’exécution en fonction de la valeur de la variable.
Comme les types de données ne sont déclarés explicitement qu’au moment de l’exécution, lorsque vous effectuez des opérations nécessitant différents types de données, JavaScript vérifie automatiquement leur compatibilité pour l’opération que vous souhaitez effectuer. S’ils sont compatibles entre eux, l’opération se déroule normalement.
Cependant, supposons qu’ils soient incompatibles avec l’opération – par exemple, en essayant d’additionner une chaîne de caractères et un nombre. Dans ce cas, JavaScript « contraint » automatiquement l’un des types à s’adapter à l’autre afin de garantir la réussite de l’opération au lieu de générer une erreur. Ce processus est connu sous le nom de coercition de type ou coercition implicite.
Coercition de type
La coercition de type est la conversion automatique d’une valeur d’un type de données à un autre, effectuée par JavaScript pendant l’exécution d’un programme afin de s’assurer qu’une opération s’exécute correctement.
Mais tous les types de données ne peuvent pas être contraints. Les chaînes de caractères, les nombres et les booléens sont les seuls types de données JavaScript que le langage peut convertir en un type différent. Lorsque vous essayez d’effectuer une opération incompatible avec des types de données que JavaScript ne peut pas forcer, il génère une erreur.
JavaScript contraint les types en fonction du type d’opération et de l’opérateur que vous utilisez dans l’opération.
La coercition avec l’opérateur « + ».
En JavaScript, l’opérateur « +L’opérateur « + » a deux comportements différents en fonction des types de ses opérandes. Il peut effectuer à la fois une addition numérique et une concaténation de chaînes de caractères. Cela peut conduire à une coercition de type lorsque l’un des opérandes n’est pas du type attendu.
Si les deux opérandes sont des nombres, la balise « +L’opérateur » + » effectue une addition :
let num1 = 42;
let num2 = 10;
let sum = num1 + num2; // Addition
console.log(sum); // 52
Si les deux opérandes sont des chaînes de caractères, l’opérateur « +L’opérateur » + » permet de concaténer des chaînes de caractères :
let str1 = "Hello";
let str2 = "world";
let result = str1 + " " + str2; // String concatenation
console.log(result); // "Hello world"
Cependant, si l’un des opérandes n’est pas une chaîne de caractères, JavaScript le contraindra implicitement à devenir une chaîne de caractères avant d’effectuer la concaténation :
// Number and String
let num = 42;
let str = "Hello";
// num is coerced to a string and then concatenated
let result_1 = num + str;
console.log(result_1); // "42Hello"
// String and Boolean
let bool = true;
// bool is coerced to a string and then concatenated
let result_2 = bool + str;
console.log(result_2); // "trueHello"
Coercion avec l’opérateur « – » (en anglais)
En JavaScript, l’opérateur « –L’opérateur » est principalement utilisé pour les opérations de soustraction. Lorsqu’un ou les deux opérandes d’une opération impliquant l’opérateur « –Si l’opérateur » n’est pas un nombre, JavaScript essaiera de le forcer à devenir un nombre.
Lorsque les deux opérandes sont des nombres, JavaScript effectue une soustraction. Il effectue également une soustraction lorsque l’un des opérandes ou les deux sont des chaînes de caractères représentant un nombre :
const num1 = 10;
const num2 = 20;
const result_1 = num2 - num1; // Subtraction
console.log(result_1); // 10
const strNum = "10";
const strNum2 = "20";
const result = strNum2 - strNum; // Type coercion to numbers, then subtraction
console.log(result_1); // 10
Si aucun des opérandes n’est un nombre ou une chaîne représentant un nombre, JavaScript tente de contraindre le type de données à son équivalent numérique. Si le type de données n’a pas d’équivalent numérique, l’opération renverra NaN (Not a Number) :
// true gets coerced to 1, false gets coerced to 0
const boolNum = true;
const boolNum2 = false;
const result_1 = boolNum - boolNum2;
console.log(result_1); // 1
// empty arrays get coerced to 0
const arrNum = [];
const arrNum2 = [];
const result_2 = arrNum - arrNum2;
console.log(result_2); // 0
// empty objects get coerced to NaN
const objNum = {};
const result_3 = arrNum - objNum;
console.log(result_3); // 0 - NaN = NaN
Dans cet exemple, JavaScript impose des valeurs booléennes. vrai et faux à leurs valeurs numériques équivalentes, 1 et 0, respectivement. Les tableaux vides sont contraints à 0, et les objets vides sont contraints à NaN.
Coercion avec les opérateurs d’égalité (==)/(===)
En JavaScript, les opérateurs d’égalité (== et ===) comparent des valeurs pour l’égalité. Cependant, elles se comportent différemment en raison de la coercition de type.
L’élément « ==L’opérateur » (loose equality) effectue une coercion de type, c’est-à-dire qu’il tente de convertir les opérandes en un même type avant de les comparer :
"10" == 10; // true
Dans cet exemple, JavaScript convertit la chaîne de caractères « 10 » en un nombre 10, de sorte que l’expression est évaluée à vrai.
Cependant, le « ===L’opérateur » (stricte égalité) n’effectue pas de coercition de type. Il exige que la valeur et le type soient identiques pour que la comparaison retourne vrai:
"10" === 10; // false
Dans cet exemple, la comparaison renvoie faux car les opérandes sont de types différents (chaîne et nombre).
Vous devriez généralement utiliser l’option === (stricte égalité) en JavaScript pour éviter un comportement inattendu de coercion de type.
La coercition de type ou la conversion implicite peut entraîner un comportement inattendu en raison de sa nature automatique. Dans les cas où vous devez convertir des types, il est conseillé de les convertir explicitement. Le processus de conversion explicite des types est connu sous le nom de conversion de type. On parle également de moulage de type et de conversion explicite de type.
Conversion de type
La conversion de type, également connue sous le nom de casting de type, est le processus explicite de conversion d’une valeur d’un type de données à un autre en JavaScript en utilisant des fonctions intégrées telles que Number(), String(), Booléen(), parseInt()et parseFloat().
Vous pouvez effectuer une conversion de type en passant la valeur que vous souhaitez convertir aux fonctions de conversion intégrées en tant qu’argument. Ces fonctions convertissent alors votre valeur dans le type souhaité.
Voici un exemple utilisant la fonction Number() fonction :
const numStr = "123";
const num = Number(numStr); // Converts a string to a number
console.log(num); // 123
Passer une chaîne de caractères qui est un nombre valide comme argument à la fonction Number() renvoie un nombre. Passer une chaîne de caractères qui est un nombre invalide renverra NaN.
Voici un exemple utilisant la fonction String() fonction :
const bool = true;
const str2 = String(bool); // Converts a boolean to a string
console.log(str2); // "true"
Passer n’importe quel type de données dans la fonction sauf un symbole dans la fonction String() convertit le type de données en chaîne de caractères.
Voici un exemple utilisant la fonction Booléen() fonction :
// Convert a string to a boolean (truthy: true, falsy: false)
const str = "hello";
const bool2 = Boolean(str);
console.log(bool2); // true
Passer des valeurs vraies à la fonction Boolean() La fonction « Boolean() » renvoie le booléen « true » tandis que les valeurs « falsy » renvoient le booléen « false ».
Voici un exemple utilisant la fonction ParseInt() et ParseFloat() fonction :
// Convert a string to an integer
const numStr = "123.00";
const num1 = parseInt(numStr);
console.log(num1); // 123
// Convert a string to a floating-point number
const floatStr = "3.14";
const num2 = parseFloat(floatStr);
console.log(num2); // 3.14
Le parseInt() analyse une chaîne de caractères et renvoie un nombre entier. La fonction parseFloat() convertit une chaîne de caractères en un nombre à virgule flottante.
Exploiter la coercition de type et la conversion
En comprenant la coercition et la conversion de type, vous pouvez prendre des décisions éclairées sur le moment et la manière de les exploiter efficacement dans votre code. Il est important de trouver le bon équilibre, en utilisant judicieusement la coercition de type pour un code concis et pratique et en s’appuyant sur la conversion de type explicite pour des conversions de type intentionnelles et prévisibles.
