A brief discussion on implicit type conversion in JavaScript

JavaScript’s data type is divided into six types, namely null, undefined, boolean, string,number,object. Object is a reference type, the other five types are basic types or primitive types. We can use the typeof method to print out which type something belongs to. When comparing variables of different types, the type must be converted first, which is called type conversion. Type conversion is also called implicit conversion. Implicit conversions usually occur with operatorsaddition, subtraction, multiplication, division, equals, and less than, greater than, etc. .

typeof '11'  //string       
typeof(11) 　//number
&#39;11&#39; < 4     //false

Conversion of basic types

Let’s talk about addition, subtraction, multiplication and division first:

1.StringAdd numbers, numbers will be converted into a string.

2. Subtract strings from numbers and convert strings into numbers. If the string is not a pure number, it will be converted to NaN. The same goes for string minus numbers. Subtracting two strings also converts them into numbers first.

3. The same applies to conversions of multiplication, division, greater than, less than and subtraction.

//隐式转换 + - * == / 
// + 
10 + '20'    //2010
// -
10 - '20'    //-10
10 - 'one'   //NaN
10 - '100a'  //NaN
// *
10*'20'      //200
'10'*'20'    //200
// /
20/'10'      //2
'20'/'10'    //2
'20'/'one'　 //NaN

Let’s take a look at a group of ==.

1. undefined equals null

2. When comparing strings and numbers, convert strings to numbers

3. When comparing numbers to Boolean, convert Boolean to numbers

4. When comparing strings and Boolean, convert the two to numbers

// ==
undefined == null;    //true
'0' == 0;        　　  //true,字符串转数字
0 == false;           //true,布尔转数字
'0' == false;    　　　//true,两者转数字
null == false;     　 //false
undefined == false; 　//false

Conversion of reference types

The comparison between basic types is relatively simple. The comparison between reference types and basic types is relatively complicated. First, the reference type must be converted into a basic type, and then compared according to the above method. Reference types converted to Boolean are all true. For example, an empty array, as long as it is an object, is a reference type, so [] is true. To convert a reference type to a number or a string, use valueOf() or toString(); the object itself inherits valuOf() and toString(), and you can also customize valueOf() and toString(). Depending on the object, use the inherited valueOf() to convert it to a string, a number or itself, and the object must be converted to a string using toString. General objects call valueOf() by default. 1. When converting an object to a number, call valueOf();

2. When converting an object to a string, call toString();

First look at the following example:

0 == [];        // true, 0 == [].valueOf(); -> 0 == 0;
'0' == [];      // false, '0' == [].toString(); -> '0' == '';
2 == ['2'];     // true, 2 == ['2'].valueOf(); -> 2 == '2' -> 2 == 2;
'2' == [2];     // true, '2' == [2].toString(); -> '2' =='2';

[] == ![];      //true, [].valueOf() == !Boolean([]) -> 0 == false -> 0 == 0;

When the object is converted into a number, valueOf() is called. Before that, toString() is called; so I guess the valueOf method is like this. So the above example 0 == [] should be changed to the following which is more reasonable. In any case, [] is eventually converted to 0.

var valueOf = function (){
    var str = this.toString();    //先调用toString(),转成字符串
    //...
}
0 == [];        // true, 0 == [].valueOf(); -> 0 == '0' -> 0 == 0;

Customized valueOf() and toString();

1. Customized valueOf() and toString() both exist and will be called by default valueOf();

2. If there is only toString(), call toString();

var a = [1];

a.valueOf = function (){ return 1;}
a.toString = function (){ return '1';}

a + 1;         // 2, valueOf()先调用

Removing valueOf() will call toString().

var a = [1];

a.valueOf = function (){ return 1;}
a.toString = function (){ return '1';}

a + 1;         // 2, 先调用valueOf()
//去掉valueOf
delete a.valueOf;
a + 1;        // '11', 调用toString()

What happens if something else is returned?

var a = [1];

a.valueOf = function (){return ;}
a.toString = function (){return 1 ;};

1 - a;        //NaN

Other objects call valueOf() to convert to different types:

var a = {};
a.valueOf();    //Object {}
var a = [];
a.valueOf();    //[]    自己本身
var a = new Date();
a.valueOf();    //1423812036234  数字
var a = new RegExp();
a.valueOf();    //    /(?:)/  正则对象

The comparison between reference types is the comparison of memory addresses and does not require implicit conversion. I won’t go into details here.

[] == []  //false 地址不一样

var a = [];
b = a;
b == a   //true

Explicit conversion

Explicit conversion is relatively simple, you can directly use the class as a method to convert directly.

Number([]);        //0
String([]);        //''
Boolean([]);       //true

There is an easier conversion method.

3 + ''    // 字符串'3'
+'3'      // 数字3
!!'3'     // true

The above is the detailed content of A brief discussion on implicit type conversion in JavaScript. For more information, please follow other related articles on the PHP Chinese website!