Summary of some implicit conversions in JS

This time I will bring you a summary of some implicit conversions in JS. What are the precautions for using JS implicit conversion? . Here are practical cases. Let’s take a look.

The comparison and conversion rules between different data types in js are as follows:

1. Comparison of objects and Boolean values

When comparing objects and Boolean values, the object is first converted to a string and then converted to a number, and the Boolean value is directly converted to a number

[] == true; //false []转换为字符串'',然后转换为数字0,true转换为数字1，所以为false

2. Object and String comparison

When comparing objects and strings, the object is converted to a string, and then the two are compared.

[1,2,3] == '1,2,3' // true [1,2,3]转化为'1,2,3'，然后和'1,2,3'， so结果为true;

3. Comparison of objects and numbers

When comparing an object with a number, the object is first converted to a string, then converted to a number, and then compared with the number.

[1] == 1; // true `对象先转换为字符串再转换为数字，二者再比较 [1] => '1' => 1 所以结果为true

4. String and number comparison

When strings and numbers are compared, the strings are converted into numbers, and then the two are compared.

'1' == 1 // true

5. String and Boolean comparison

When comparing strings and Boolean values, both are converted into numerical values ​​and then compared.

'1' == true; // true

6. Boolean and number comparison

When comparing Boolean values ​​to numbers, the Boolean is converted to a number and the two are compared.

true == 1 // true

When comparing any two types, if they are not of the same type, the corresponding type conversion will be performed as shown in the figure. For example, if object and Boolean are compared, object => character string=> numeric value boolean=> numeric value.
In addition, let's take a look at some things that require "special care".

Let’s take a look at an interesting question

[] == false;
![] == false;

The results of these two are both true. The first one is, object => string => value 0 false converted to number 0. This should be true if it is true.
There is an extra ! in front of the second one!, Then directly convert to a Boolean value and then negate it. When converted to a Boolean value, the empty string (''), NaN, 0, null, and undefined will all return true, so! []this[] => ; The negation of true is false, so [] == false is true.

There are some more things to remember, like:

undefined == null //true undefined和null 比较返回true，二者和其他值比较返回false
Number(null) //0

I once saw such a code: (!(~ []) {})[--[~ ""][ []]*[~ []] ~~! []] ({} [] )[[~! []*~ []]] = sb , can you believe it, it shocked the baby at that time.

When I first came into contact with it, JS was very confusing to me, precisely because of its ‘fickleness’. Let me summarize it below:

7. JS data types: Number, Boolean, String, Undefined, Null, Symbol (newly defined in es6) and Object (Note: Array is a special Object)

7 types returned by typeof: number boolean string object undefined object function

MDN introduces Javascript like this: JavaScript is a weakly typed or dynamic language. This means that you don't need to declare the type of the variable in advance, the type will be determined automatically during the execution of the program. This also means that you can use the same variable to store different types of data

8. Let’s take a look at common implicit conversions:

basic type:

Conversion type

when the operator ( ,-,*,/,%) operates ˆ ˆ ˆ” “ sign operator: ˆ ˆ ˆ ˆ ˆ

Summary: When using the plus sign operator, String and other types will be converted to String; in other cases, they will be converted to Number type. Note: undefined is converted to Number as 'NaN', and any number added to NaN will be is NaN.

When other operators are used, the basic types are converted to Number. String types with characters, such as: '1a', 'a1', are converted to NaN, which is the same as undefined.

Tip: (1) NaN is not equal to any value, including itself, so to determine whether a value is NaN, use "! ==".　　

ˆ ˜ ˜ (2) Conversion to Boolean type as false includes: null, 0, '', undefined, NaN, false ˜

        （3）number（） 与 parseInt（） 都可以将对象转化为Number类型，Number函数要比parseInt函数严格很多。基本上，只要有一个字符无法转成数值，整个字符串就会被转为NaN。    

  Object类型

    当object与基本类型运算时：

var obj = {
  toString: function(){
    return 6;
  },
  valueOf: function(){
    return 5;
  }
};
var obj1 = {
  valueOf: function(){
    return 'a';
  },
  toString: function(){
    return 'b';
  }
};

  总结： Number类型会先调用valueOf(), String类型会先调用toString(),  如果结果是原始值，则返回原始值，否则继续用toString 或 valueOf(),继续计算，如果结果还不是原始值，则抛出一个类型错误; 

为什么 {} + [] = 0 ?  因为 javascript在运行时, 将 第一次{} 认为是空的代码块，所以就相当于 +[] = 0.  还有 {} +5 = 5, 同理。

总结:

1. 类型错误有可能会被类型转换所隐藏。

2. “+”既可以表示字符串连接，又可以表示算术加，这取决于它的操作数，如果有一个为字符串的，那么，就是字符串连接了。

3. 对象通过valueOf方法，把自己转换成数字，通过toString方法，把自己转换成字符串。

4.具有valueOf方法的对象，应该定义一个相应的toString方法，用来返回相等的数字的字符串形式。

5.检测一些未定义的变量时，应该使用typeOf或者与undefined作比较，而不应该直接用真值运算。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

The above is the detailed content of Summary of some implicit conversions in JS. For more information, please follow other related articles on the PHP Chinese website!