Comprendre la conversion de type et la coercion 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 des valeurs de types différents, afin de les comparer.

Comprendre la conversion de type et la coercion 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 ont-elles lieu 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.

Étant donné que 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’ajouter 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 provoquer 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 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. 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 contraindre, 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.

Coercition avec l’opérateur « + ».

En JavaScript, l’opérateur « +« a deux comportements différents selon le type 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 fonction « +« effectue une addition :

Si les deux opérandes sont des chaînes de caractères, l’opérateur « +« effectue une concaténation de chaînes de caractères :

Toutefois, si l’un des opérandes n’est pas une chaîne, JavaScript le contraint implicitement à devenir une chaîne avant d’effectuer la concaténation :

Coercition avec l’opérateur « –

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 « –« n’est pas un nombre, JavaScript essaiera de le transformer en 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 :

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 renvoie le résultat suivant NaN (Pas un nombre) :

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 convertis en 0, et les objets vides sont contraints à NaN.

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

En JavaScript, les opérateurs d’égalité (== et ===) comparent des valeurs pour vérifier leur égalité. Cependant, ils se comportent différemment en raison de la coercition de type.

La fonction « ==« (égalité libre) effectue une coercion de type, ce qui signifie qu’il tente de convertir les opérandes dans le même type avant la comparaison :

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, l’expression « ===« (égalité stricte) n’effectue pas de coercion de type. Il exige que la valeur et le type soient identiques pour que la comparaison renvoie vrai:

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

En règle générale, il convient d’utiliser l’option === (égalité stricte) 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 convertir explicitement les types. 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 de type explicite.

Conversion de type

La conversion de type, également connue sous le nom de moulage 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 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() de la fonction Number() :

En passant une chaîne de caractères qui est un nombre valide comme argument à la fonction Nombre() renvoie un nombre. Si une chaîne de caractères est un nombre invalide, la fonction renverra NaN

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

Passer n’importe quel type de données dans la fonction, à l’exception d’un symbole dans la fonction Chaîne() convertira le type de données en chaîne de caractères.

Voici un exemple utilisant la fonction Booléen() de la fonction Boolean() :

Transmettre des valeurs vraies à la fonction Booléen() renvoie le booléen « true » tandis que le passage de valeurs erronées renvoie le booléen « false ».

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

La fonction 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.

Exploitation de la coercition et de la conversion des types

En comprenant la coercion et la conversion de types, vous pouvez prendre des décisions éclairées sur le moment et la manière de les utiliser 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.

S’abonner à notre lettre d’information