Comprendre la conversion de type et la coercition en JavaScript

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 les valeurs de différents types, pour 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 meilleures 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 ne vous oblige pas à définir 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.

Étant donné que les types de données ne sont pas explicitement déclarés avant l'exécution, lorsque vous effectuez des opérations nécessitant des données différentes types, JavaScript vérifie automatiquement leur compatibilité entre eux 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, essayer d'ajouter une chaîne et un nombre. Dans de tels cas, JavaScript "contraint" automatiquement l'un des types à s'adapter à l'autre pour s'assurer que l'opération réussit au lieu de générer une erreur. Ce processus est connu sous le nom de coercition de type ou coercition implicite.

Type de coercition

La coercition de type est la conversion automatique d'une valeur d'un type de données à un autre, effectuée par JavaScript lors de l'exécution d'un programme pour s'assurer qu'une opération s'exécute avec succès.

Mais tous les types de données ne peuvent pas être contraints. Chaîne, nombre et booléen sont les seuls Types de données JavaScript que la langue contraindra dans un type différent. Lorsque vous essayez d'effectuer une opération incompatible avec des types de données que JavaScript ne peut pas contraindre, cela 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.

Coercition avec l'opérateur "+"

En JavaScript, le "+L'opérateur ” a deux comportements différents selon les types de ses opérandes. Il peut effectuer à la fois une addition numérique et une concaténation de chaînes. 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, le "+” l'opérateur effectue l'addition :

laisser num1 = 42;
laisser num2 = 10;
laisser somme = num1 + num2; // Ajout
console.log (somme); // 52

Si les deux opérandes sont des chaînes, le "+L'opérateur ” effectue la concaténation des chaînes :

laisser chaîne1 = "Bonjour";
laisser chaîne2 = "monde";
laisser résultat = str1 + " " + str2; // Concaténation de chaînes
console.log (résultat); // "Bonjour le monde"

Cependant, si l'un des opérandes n'est pas une chaîne, JavaScript le contraindra implicitement dans une chaîne avant d'effectuer la concaténation :

// Nombre et chaîne
laisser nombre = 42;
laisser chaîne = "Bonjour";
// num est contraint à une chaîne puis concaténé
laisser result_1 = num + str ;
console.log (résultat_1); // "42Bonjour"
// Chaîne et booléen
laisser bool = vrai;
// bool est converti en chaîne puis concaténé
laisser result_2 = bool + str ;
console.log (result_2); // "vraiBonjour"

Coercition avec l'opérateur "-"

En JavaScript, le "-L'opérateur ” est principalement utilisé pour les opérations de soustraction. Lorsqu'un ou les deux opérandes dans une opération impliquant le "-” l'opérateur n'est pas un nombre, JavaScript essaiera de le convertir en un nombre.

Lorsque les deux opérandes sont des nombres, JavaScript effectue une soustraction. Il effectue également une soustraction lorsqu'un ou les deux opérandes sont des chaînes qui représentent un nombre :

constante num1 = 10;
constante num2 = 20;
constante result_1 = num2 - num1; // Soustraction
console.log (résultat_1); // 10
constante strNum = "10";
constante strNum2 = "20";
constante résultat = strNum2 - strNum; // Tapez la coercition sur les nombres, puis la soustraction
console.log (résultat_1); // 10

Lorsqu'aucun des opérandes n'est un nombre ou une chaîne représentant un nombre, JavaScript essaiera 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 (Pas un nombre):

// true est contraint à 1, false est contraint à 0
constante boolNum = vrai;
constante boolNum2 = FAUX;
constante result_1 = boolNum - boolNum2 ;
console.log (résultat_1); // 1
// les tableaux vides sont contraints à 0
constante tabNum = [] ;
constante tabNum2 = [] ;
constante result_2 = tabNum - tabNum2 ;
console.log (result_2); // 0
// les objets vides sont contraints à NaN
constante objNum = {} ;
constante result_3 = arrNum - objNum ;
console.log (résultat_3); // 0 - NaN = NaN

Dans cet exemple, JavaScript contraint les valeurs booléennes vrai et FAUX à leurs valeurs équivalentes numériques, 1 et 0, respectivement. Les tableaux vides sont contraints à 0, et les objets vides sont contraints de NaN.

Coercition avec les opérateurs d'égalité (==)/()

En JavaScript, les opérateurs d'égalité (== et ) comparer les valeurs pour l'égalité. Cependant, ils se comportent différemment en raison de la coercition de type.

Le "==L'opérateur " (égalité lâche) effectue une coercition de type, ce qui signifie qu'il essaie de convertir les opérandes dans le même type avant la comparaison :

"10" == 10; // vrai

Dans cet exemple, JavaScript contraint la chaîne "10" au nombre 10, de sorte que l'expression est évaluée à vrai.

Cependant, le "” (égalité stricte) n'effectue pas de coercition de type. Il faut que la valeur et le type soient identiques pour que la comparaison renvoie vrai:

"10"10; // FAUX

Dans cet exemple, la comparaison renvoie FAUX car les opérandes sont de types différents (chaîne et nombre).

Vous devez généralement utiliser le (égalité stricte) en JavaScript pour éviter un comportement de coercition de type inattendu.

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 avez besoin de convertir des types, il est conseillé de convertir explicitement les types. Le processus de conversion explicite des types est appelé conversion de type. Il est également appelé transtypage de type et conversion de type explicite.

Conversion de types

La conversion de type, également connue sous le nom de conversion de type, est le processus explicite de conversion d'une valeur d'un type de données à un autre en JavaScript à l'aide de fonctions intégrées telles que Nombre(), Chaîne(), Booléen(), parseInt(), et parseFloat().

Vous pouvez effectuer une conversion de type en passant la valeur que vous souhaitez convertir dans les fonctions de conversion intégrées en tant qu'argument. Ces fonctions convertissent ensuite votre valeur dans le type souhaité.

Voici un exemple utilisant le Nombre() fonction:

constante numStr = "123";
constante nombre = Nombre(numStr); // Convertit une chaîne en nombre
console.log (num); // 123

Passer une chaîne qui est un nombre valide comme argument à la Nombre() fonction renverra un nombre. Passer une chaîne qui est un nombre invalide renverra NaN.

Voici un exemple utilisant le Chaîne() fonction:

constante bool = vrai;
constante chaîne2 = Chaîne(bool); // Convertit un booléen en chaîne
console.log (str2); // "vrai"

Passer n'importe quel type de données à l'exception d'un symbole dans le Chaîne() La fonction convertira le type de données en chaîne.

Voici un exemple utilisant le Booléen() fonction:

// Convertit une chaîne en booléen (vrai: vrai, faux: faux)
constante chaîne = "Bonjour";
constante bool2 = booléen(str);
console.log (bool2); // vrai

Transmettre des valeurs de vérité aux Booléen() La fonction renvoie le booléen « vrai » tandis que le passage de valeurs fausses renvoie le booléen « faux ».

Voici un exemple utilisant le ParseInt() et ParseFloat() fonction:

// Convertit une chaîne en entier
constante numStr = "123.00";
constante num1 = parseInt(numStr);
console.log (num1); // 123
// Convertit une chaîne en un nombre à virgule flottante
constante floatStr = "3.14";
constante num2 = parseFloat(floatStr);
console.log (num2); // 3.14

Le parseInt() La fonction analyse un argument de chaîne et renvoie un entier. Le parseFloat() La fonction convertit une chaîne en un nombre à virgule flottante.

Tirer parti de la coercition de type et de 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 les conversions de type intentionnelles et prévisibles.