Home > Article > Web Front-end > Some examples of implicit conversion and summary in JavaScript

Some examples of implicit conversion and summary in JavaScript

小云云Original: 2017-12-23 15:29:391440browse

This article mainly introduces some implicit conversions and summaries in JavaScript. It is very good and has reference value. Friends who need it can refer to it. I hope it can help everyone.

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

1. Comparison of objects and Boolean values

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

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

2. Comparison of objects and strings

When objects and strings are compared, 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 objects and numbers, the object is first converted to a string and then converted as a number, and then compare it with the number.

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

4. Comparison of strings and numbers

When comparing strings and numbers, the string is converted into a number. Then compare.

'1' == 1 // true

5. Comparison of strings and Boolean values

When strings and Boolean values are compared, both are converted to Compare the values again.

'1' == true; // true

6. Comparison of Boolean values and numbers

When Boolean values and numbers are compared, the Boolean is converted to a number, and both Compare.

true == 1 // true

Many children who are new to js are confused when they see so many conversion rules. In fact, the rules are very simple. You can write down this picture

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

Let’s look at an interesting question

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

The results of these two are true. The first one is, object=> string=> ; The value 0 false is converted to the number 0. This should be no problem if it is true.

If there is an extra ! in front of the second one, it is directly converted to a Boolean value and then inverted. When converted to a Boolean value, the empty string ('' ), NaN, 0, null, and undefined all return true, so! []This [] => true is inverted to false, so [] == false is true.

There are still some 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 confused me a lot, 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)

Typeof returns 7 types: 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 have to declare the type of the variable in advance; the type will be determined automatically while the program is running. This also means that you can use the same variable to save different types of data

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

Basic types:

　 Operators (+,-,*,/,%) convert types during operation

　　+" operator: 　　

　　　　　#, Note: undefined is converted to Number as 'NaN', and the addition of any Number and NaN is NaN.

When using other operators, 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) 转换为 Boolean类型为 false 的有：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';
  }
};