Qu’est-ce que la conversion de type implicite ? Introduction à la conversion de type implicite js

Cet article vous explique ce qu'est la conversion de type implicite ? L'introduction à la conversion de type implicite js a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'elle vous sera utile.

Les types de données JavaScript sont très faibles. 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 eux avant l'opération. Ce qui suit est l'ajout de types numériques et de types booléens :

3 + true; 
// 结果：4

Le. le résultat est une valeur numérique ! S'il s'agit d'un environnement C ou Java, l'opération ci-dessus provoquera 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. comme appeler une non-fonction, ou lire Lors de la prise d'attributs nuls ou non définis, c'est comme suit :

"hello"(1); 
//结果： error: not a function
null.x; 
// 结果：error: cannot read property 'x' of null

Dans la plupart des cas, JavaScript ne fera pas d'erreur, 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, il s'agit d'un signe arithmétique plus. est une chaîne. Le symbole de connexion dépend de ses opérandes, comme suit :

2 + 3; 
//结果： 5
"hello" + " world"; 
// 结果："hello world"

Cependant, si des chaînes et des nombres sont ajoutés, JavaScript convertira automatiquement les nombres en caractères, que le nombre vienne en premier ou la chaîne Tout d'abord, comme suit :

"2" + 3; 
// 结果："23"
2 + "3";
 //结果： "23"

Le résultat de l'ajout d'une chaîne et d'un nombre est une chaîne !

Il est à noter que le sens de fonctionnement du "+" est de gauche à droite, comme suit :

1 + 2 + "3"; 
// "33"

Cela équivaut à ce qui suit :

(1 + 2) + "3"; 
// "33"

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

1 + "2" + 3; 
// "123"

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

var x = NaN;
x === NaN; // false

Bien que JavaScript fournisse isNaN pour détecter si une valeur est NaN, Cependant , ce n'est pas très précis, car avant d'appeler la fonction isNaN, il y a un processus de conversion implicite, qui va convertir les valeurs qui ne sont pas NaN en NaN, comme suit :

isNaN("foo"); // true
isNaN(undefined); // true
isNaN({}); // true
isNaN({ valueOf: "foo" }); // true

Dans le code ci-dessus , après avoir utilisé isNaN pour tester, nous avons constaté que les chaînes, les objets non définis et même les objets renvoyaient tous vrai ! ! ! Mais ce ne sont pas des NaN.

En bref : isNaN la détection de NaN n'est pas fiable ! ! !

Il existe un moyen fiable et précis de détecter NaN.

Nous savons tous que seul NaN n'est pas égal à lui-même. Vous pouvez utiliser le signe d'inégalité (!==) pour déterminer si un nombre est égal à lui-même. Par conséquent, NaN peut ê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 manière suivante :

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

Conversion implicite des objets

Les objets peuvent être convertis en valeur primitive, la méthode la plus courante est de le 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 détecter Look. :

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

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

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

Si. un objet a à la fois la méthode valueOf et la méthode toString, alors la méthode value Of sera toujours appelée en premier, comme suit :

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

Généralement, value Of et toString doivent être exprimées autant que possible. sont les mêmes (bien que les types puissent être différents).

Le dernier type de conversion de type forcée, nous l'appelons souvent « opération de valeur de vérité », comme si, ||, &&, 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, elles sont  : false, 0, -0, "", NaN, null, undefined, car il y a des nombres, des chaînes et des objets. La valeur est fausse, il n'est donc pas sûr d'utiliser directement la conversion de valeur vraie 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 ; 🎜 >

Une façon plus précise de détecter un défini est d'utiliser le type d'opération :

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

Cette façon d'écrire peut distinguer entre 0 et undéfini :

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

Une autre méthode Il utilise des paramètres pour comparer avec undefined, comme suit :

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

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 value Of, et se convertit en chaîne via la méthode toString.

4. Les objets avec des méthodes value Of 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, le type Of ou la comparaison avec undefined doivent être utilisés directement à la place de l'opération sur la valeur vraie.

Recommandations associées :

Résumé de la conversion de type implicite JS

Comment utiliser la conversion implicite ? Résumer l'utilisation d'exemples de conversion implicite

Une brève introduction à la conversion de type implicite des types de données JavaScript_compétences Javascript

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!