Conseils de conversion de type implicite JavaScript_javascript

Les types de données de JavaScript sont très faibles (sinon on ne l'appellerait pas un langage faiblement typé) ! Lors de l'utilisation d'opérateurs arithmétiques, les types de données des deux côtés de l'opérateur peuvent être arbitraires. Par exemple, une chaîne peut être ajoutée à un nombre. La raison pour laquelle des opérations peuvent être effectuées entre différents types de données est que le moteur JavaScript effectuera silencieusement une conversion de type implicite sur ceux-ci avant l'opération. Voici l'ajout de types numériques et de types booléens :

Le résultat est une valeur numérique ! S'il s'agit d'un environnement C ou Java, l'opération ci-dessus provoquera certainement une erreur car les types de données des deux côtés de l'opérateur sont incohérents ! Cependant, en JavaScript, dans quelques cas seulement, un type incorrect provoquera une erreur, par exemple lors de l'appel d'une non-fonction ou de la lecture d'une propriété nulle ou non définie, comme suit :

Dans la plupart des cas, JavaScript ne fera pas d'erreurs, mais effectuera automatiquement la conversion de type correspondante. Par exemple, les opérateurs arithmétiques tels que -, *, / et % convertiront leurs opérandes en nombres, mais le signe " " est un peu différent. Dans certains cas, il s'agit d'un signe arithmétique plus et dans d'autres cas, c'est un signe plus. une concaténation de chaîne Symbole, les détails spécifiques dépendent de ses opérandes, comme suit :

Mais quel serait le résultat si des chaînes et des nombres étaient ajoutés ? JavaScript convertira automatiquement les nombres en caractères, que le nombre ou la chaîne vienne en premier, comme suit :

Le résultat de l'ajout d'une chaîne et d'un nombre est une chaîne. Le résultat de l'ajout d'une chaîne et d'un nombre est une chaîne. Dites des choses importantes trois fois ! ! ! ! ! !

De plus, il convient de noter que le sens de fonctionnement de " " est de gauche à droite, comme suit :

Cela équivaut à :

En revanche, les résultats suivants sont différents :

Cependant, la conversion de type implicite cache parfois certaines erreurs, par exemple, null sera converti en 0 et undefined sera converti en NaN. Il est à noter que NaN et NaN ne sont pas égaux (cela est dû à la précision des nombres à virgule flottante), comme suit :

Bien que JavaScript fournisse isNaN pour détecter si une certaine valeur est NaN, cela n'est pas très précis car il existe un processus de conversion implicite avant d'appeler la fonction isNaN, qui convertira les valeurs qui ne sont pas à l'origine NaN en NaN. , comme suit :

Après avoir testé le code ci-dessus avec isNaN, nous avons constaté que les chaînes, les objets non définis et même les objets renvoyaient tous vrai ! ! ! Cependant, on ne peut pas dire qu'ils sont aussi NaN, n'est-ce pas ? Dans l’ensemble, la conclusion est la suivante : la détection de NaN par isNaN n’est pas fiable ! ! !

Heureusement, il existe un moyen fiable et précis de détecter NaN. Nous savons tous que NaN est le seul qui ne s'égale pas à lui-même. Ensuite, nous pouvons utiliser le signe d'inégalité (!==) pour déterminer si un nombre est égal à lui-même, afin que NaN puisse être détecté, comme suit :

var a = NaN;
a !== a; // true
var b = "foo";
b !== b; // false
var c = undefined;
c !== c; // false
var d = {};
d !== d; // false
var e = { valueOf: "foo" };
e !== e; // false

On peut également définir ce mode comme une fonction, de la façon suivante :

function isReallyNaN(x) {
return x !== x;
}

OK, la méthode de détection NaN est aussi simple que cela. Continuons à discuter de la conversion implicite des objets !

Les objets peuvent être convertis en valeurs primitives. La méthode la plus courante consiste à les convertir en chaîne, comme suit :

"the Math object: " + Math; // "the Math object: [object Math]"
"the JSON object: " + JSON; // "the JSON object: [object JSON]"

L'objet est converti en chaîne en appelant sa fonction toSting. Vous pouvez l'appeler manuellement pour vérifier :

Math.toString(); // "[object Math]"
JSON.toString(); // "[object JSON]"

De même, les objets peuvent également être convertis en nombres via la fonction valueOf. Bien entendu, vous pouvez également personnaliser cette fonction valueOf, comme suit :

"J" + { toString: function() { return "S"; } }; // "JS"
2 * { valueOf: function() { return 3; } }; // 6

Si un objet possède à la fois la méthode valueOf et la méthode toString, alors la méthode valueOf sera toujours appelée en premier, comme suit :

var obj = {
toString: function() {
return "[object MyObject]";
},
valueOf: function() {
return 17;
}
};
"object: " + obj; // "object: 17"

Cependant, dans la plupart des cas, ce n'est pas ce que nous voulons. En général, essayez de rendre les valeurs représentées par valueOf et toString identiques (bien que les types puissent être différents).

Le dernier type de conversion de type forcé est souvent appelé « opération de vérité », comme if, ||, &&. Leurs opérandes ne sont pas nécessairement booléens. JavaScript convertira certaines valeurs non booléennes en valeurs booléennes grâce à des règles de conversion simples. La plupart des valeurs seront converties en vrai, seules quelques-unes sont fausses, ce sont : false, 0, -0, ”", NaN, null, indéfini, car il y a des nombres, des chaînes et des objets avec de fausses valeurs, donc, Il n'est pas très sûr d'utiliser directement la conversion de valeur de vérité pour déterminer si les paramètres d'une fonction sont transmis. Par exemple, il existe une fonction qui peut avoir des paramètres facultatifs avec des valeurs par défaut, comme suit :

function point(x, y) {
if (!x) {
x = 320;
}
if (!y) {
y = 240;
}
return { x: x, y: y };
}

Cette fonction ignorera tout paramètre dont la vraie valeur est fausse, y compris 0, -0

Un moyen plus précis de détecter un élément non défini consiste à utiliser le type d'opération :

function point(x, y) {
if (typeof x === "undefined") {
x = 320;
}
if (typeof y === "undefined") {
y = 240;
}
return { x: x, y: y };
}

Cette façon d'écrire permet de distinguer entre 0 et indéfini :

point(); // { x: 320, y: 240 }
point(0, 0); // { x: 0, y: 0 }

Une autre méthode consiste à utiliser des paramètres pour comparer avec undéfini, comme suit :

if (x === undefined) { ... }

Résumé :

1. Les erreurs de type peuvent être masquées par la conversion de type.

2. " " peut représenter à la fois une concaténation de chaînes et une addition arithmétique, en fonction de ses opérandes. Si l'un d'eux est une chaîne, alors il s'agit d'une concaténation de chaînes.

3. L'objet se convertit en nombre via la méthode valueOf et se convertit en chaîne via la méthode toString.

4. Les objets avec les méthodes valueOf doivent définir une méthode toString correspondante pour renvoyer des nombres égaux sous forme de chaîne.

5. Lors de la détection de certaines variables non définies, typeOf ou comparaison avec undefined doit être utilisé directement à la place de l'opération sur la valeur vraie.

C'est tout pour tout le monde sur la conversion de type implicite JavaScript, j'espère que cela vous sera utile !