How to use Javascript implicit conversion? (code example)

The content of this article is about how to use Javascript implicit conversion? (Code sample) has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Determining whether two variables are equal is a very important operation in programming.
When comparing the equality of strings, numbers and Boolean values, the problem is relatively simple. But when it comes to comparing objects, the problem becomes complicated. The original equality and inequality operators in ECMAScript converted objects to similar types before performing comparisons. Later, some people raised questions about whether this conversion was reasonable.
Finally, ECMAScript's solution is to provide two sets of operators:
Equality and inequality - convert first and then compare, congruence and inequality - only compare without conversion.
Here we only discuss equality.

"==" Implicit conversion when equal

For the "==" operator, implicit conversion (forced conversion) is usually performed first, and then compared their equality.

Implicit conversion rules:

1. If one of the operands is a Boolean value, convert it to a numeric value before comparing for equality— —false is converted to 0, and true is converted to 1;

2. If one operand is a string and the other operand is a numeric value, convert the string to a numeric value before comparing equality;
Convert strings to numerical values:

(1) Numeric strings will be converted to corresponding decimal values;
(2) Empty strings will be converted to 0;
(3 ) The rest will all be converted to NaN; (NaN is not equal to any value, including itself)

3. If one operand is an object and the other operand is not, call the object's valueOf() method , use the obtained basic type value to compare according to the previous rules;

The following can take a look at the underlying conversion rules of JS through a simple example.

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

Now we can take a look at the example. Why is the empty object not equal to false? From a normal perspective, an array is an object. Why is an empty array equal to false, and why is an empty object not equal to false?

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

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

Special rules for implicit conversions:

1. null and undefined are equal.

2. null and undefined cannot be converted to any other value before comparing for equality.

3. If one of the operands is NaN, the equality operator returns false, and the inequality operator returns true.

4. If both operands are objects, compare whether they are the same object. (Compare whether the addresses of reference types are the same)

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

The above is the detailed content of How to use Javascript implicit conversion? (code example). For more information, please follow other related articles on the PHP Chinese website!