Wie verwende ich die implizite Javascript-Konvertierung? (Codebeispiel)

Der Inhalt dieses Artikels befasst sich mit der Verwendung der impliziten Javascript-Konvertierung. (Codebeispiel) hat einen gewissen Referenzwert. Freunde in Not können darauf verweisen.

Die Feststellung, ob zwei Variablen gleich sind, ist ein sehr wichtiger Vorgang in der Programmierung.
Beim Vergleich von Zeichenfolgen, Zahlen und booleschen Werten auf Gleichheit ist das Problem relativ einfach. Beim Vergleich von Objekten wird das Problem jedoch komplizierter. Die ursprünglichen Gleichheits- und Ungleichheitsoperatoren in ECMAScript konvertierten Objekte in ähnliche Typen, bevor sie Vergleiche durchführten. Später stellten einige Leute die Frage, ob diese Umstellung sinnvoll sei.
Schließlich besteht die Lösung von ECMAScript darin, zwei Sätze von Operatoren bereitzustellen:
Gleichheit und Ungleichheit – zuerst konvertieren und dann vergleichen, Kongruenz und Ungleichheit – nur vergleichen, ohne Konvertierung.
Hier diskutieren wir nur über Gleichberechtigung.

"==" Implizite Konvertierung bei Gleichheit

Für den Operator "==" wird normalerweise zuerst eine implizite Konvertierung (erzwungene Konvertierung) durchgeführt und dann ihre Gleichheit verglichen .

Implizite Konvertierungsregeln:

1. Wenn einer der Operanden ein boolescher Wert ist, konvertieren Sie ihn vor dem Vergleich auf Gleichheit in einen numerischen Wert – –false wird in 0 konvertiert und true wird in 1 konvertiert;

2 Wenn ein Operand eine Zeichenfolge und der andere Operand ein numerischer Wert ist, wird die Zeichenfolge vor dem Vergleich auf Gleichheit in einen numerischen Wert konvertiert;
Zeichenfolgen in numerische Werte konvertieren:

(1) Numerische Zeichenfolgen werden in entsprechende Dezimalwerte umgewandelt; (2) Leere Zeichenfolgen werden in 0 umgewandelt;
(3) Der Rest wird alle in NaN konvertiert werden; (NaN entspricht keinem Wert, einschließlich sich selbst)

3 Wenn ein Operand ein Objekt ist und der andere nicht, rufen Sie die valueOf()-Methode des Objekts auf und verwenden Sie die erhaltene Basis Geben Sie den zu vergleichenden Wert gemäß den vorherigen Regeln ein.

Im Folgenden können Sie anhand eines einfachen Beispiels einen Blick auf die zugrunde liegenden Konvertierungsregeln von JS werfen.

    // 根据隐式转换规则第三条 调用对象的 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

Jetzt können wir uns das Beispiel ansehen: Warum ist das leere Objekt nicht gleich false? Aus normaler Sicht ist ein Array ein Objekt. Warum ist ein leeres Array gleich false und warum ist ein leeres Objekt nicht gleich false?

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

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

Sonderregeln für implizite Konvertierungen:

1. null und undefiniert sind gleich.

2. Null und undefiniert können vor dem Vergleich auf Gleichheit nicht in einen anderen Wert umgewandelt werden.

3. Wenn einer der Operanden NaN ist, gibt der Gleichheitsoperator „false“ und der Ungleichheitsoperator „true“ zurück.

4. Wenn beide Operanden Objekte sind, vergleichen Sie, ob es sich um dasselbe Objekt handelt. (Vergleichen Sie, ob die Adressen der Referenztypen gleich sind)

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

Das obige ist der detaillierte Inhalt vonWie verwende ich die implizite Javascript-Konvertierung? (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!