Comment utiliser la conversion implicite Javascript ? (exemple de code)

Le contenu de cet article explique comment utiliser la conversion implicite Javascript ? (Exemple de code) a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère que cela vous sera utile.

Déterminer si deux variables sont égales est une opération très importante en programmation.
Lorsque l'on compare des chaînes, des nombres et des booléens pour déterminer l'égalité, le problème est relativement simple. Mais lorsqu’il s’agit de comparer des objets, le problème se complique. Les opérateurs d'égalité et d'inégalité d'origine dans ECMAScript convertissaient les objets en types similaires avant d'effectuer des comparaisons. Plus tard, certaines personnes se sont demandées si cette conversion était raisonnable.
Enfin, la solution d'ECMAScript consiste à fournir deux ensembles d'opérateurs :
Égalité et inégalité - convertir d'abord puis comparer, congruence et inégalité - comparer uniquement sans conversion.
Ici, nous ne discutons que d'égalité.

"==" Conversion implicite lorsque égal

Pour l'opérateur "==", la conversion implicite (conversion forcée) est généralement effectuée en premier, puis comparée leur égalité .

Règles de conversion implicites :

1 Si l'un des opérandes est une valeur booléenne, convertissez-la en valeur numérique avant de comparer pour l'égalité — —false. est converti en 0 et true est converti en 1 ;

2 Si un opérande est une chaîne et l'autre opérande est une valeur numérique, la chaîne est convertie en valeur numérique avant de comparer l'égalité ; Convertir les chaînes en valeurs numériques :

(1) Les chaînes numériques seront converties en valeurs décimales correspondantes

(2) Les chaînes vides seront converties en 0
(3) Le reste sera tous ; être converti en NaN ; (NaN n'est égal à aucune valeur, y compris elle-même)

3. Si un opérande est un objet et que l'autre ne l'est pas, appelez la méthode valueOf() de l'objet, utilisez la base obtenue. tapez la valeur à comparer selon les règles précédentes ;

Ce qui suit peut jeter un œil aux règles de conversion sous-jacentes de JS à travers un exemple simple.

    // 根据隐式转换规则第三条 调用对象的 valueOf 方法
    [].valueOf() // []

    // 这时就变成 [] == false ，又回到原来的情况，这时JS底层又是怎么处理的呢？
    // 其实 JS 的底层在调用 valueOf 得到的返回结果如果不是原始值时，就会调用对象的 toString 方法将对象转换成字符串。对于这个过程我们可以通过一下的例子来验证。

    [].valueOf() // []
    [].toString() // ''
    //上面是 这两个方法的 默认行为，在下面的例子中我们不改变默认行为
    [].__proto__.valueOf = () => { console.log('valueOf'); return []; }
    [].__proto__.toString = () => { console.log('toString'); return ''; }
    [] == false
    // 运行的结果为 valueOf toString true
    // 这样就验证了上述的说明


　　　   // 我们还可以通过下面的方式，从侧面在次验证 JS底层默认的转换行为

    [].__proto__.valueOf = () => { console.log('valueOf'); return ''; }
    [].__proto__.toString = () => { console.log('toString'); return ''; }
    [] == false
    // valueOf true

    [].__proto__.valueOf = () => { console.log('valueOf'); return []; }
    [].__proto__.toString = () => { console.log('toString'); return []; }
    [] == false
    // JS 报错 Uncaught TypeError: Cannot convert object to primitive value

Maintenant, nous pouvons jeter un œil à l'exemple. Pourquoi l'objet vide n'est-il pas égal à false ? D'un point de vue normal, un tableau est un objet. Pourquoi un tableau vide est-il égal à faux et pourquoi un objet vide n'est-il pas égal à faux ?

    //现在我们可以参照上面隐式转换的过程，对空对象手动的执行这个过程，结果如下
    ({}).valueOf() // {}
    ({}).toString() // '[object Object]'

    // 这时我们发现 空对象 与 空数组默认行为的区别了，在 toString 方法上，由于数组会对继承自对象的 toString 方法进行重写，将数组中的每个元素通过 ',' 链接成一个字符串
    // 这时就变成了 '[object Object]' == false 
    // 根据规则第二条，得到最后结果 false

Règles spéciales pour les conversions implicites :

1. null et indéfini sont égaux.

2. Null et indéfini ne peuvent pas être convertis en une autre valeur avant d'être comparés pour l'égalité.

3. Si l'un des opérandes est NaN, l'opérateur d'égalité renvoie faux et l'opérateur d'inégalité renvoie vrai.

4. Si les deux opérandes sont des objets, comparez s'il s'agit du même objet. (Comparez si les adresses des types de référence sont les mêmes)

    null == undefined  // true
    NaN == NaN         // false
    NaN != NaN         // true
    false == 0         // true
    undefined == 0     // true
    null == 0          // true

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!