javascript 隐式类型转换

javascript的数据类型包括：

（1）基本数据类型：number、string、boolean、null、undefined

（2）对象：object

　　　　object又包括Function、Array、Date、RegExp等

javascript的隐式类型转换，是相对于显示类型转换来说的。

明确的将某种类型转换成另一种类型称为显示转换，相反则称为隐式类型转换。

显示类型转换的方法Number()、Boolean()、String()、toString() 等

隐式类型转换包括运算、语句等

一、运算中的隐式类型转换

1、递增递减操作符

递增“++” 、 递减“--” 运算符不仅适用于整数，还可以用于字符串、布尔值、浮点数值和对象。

转换方式如下：

（1）是包含有效数字字符的字符串时，先将其转换为数字值，再进行运算

（2）是不包含有效数字字符的字符串时，将其值转换为NaN

（3）是布尔值时，false转换为数值0，true转换为数值1

（4）是对象时，先调用对象的valueOf()方法，以取得一个可供操作的值，如果结果是NaN，调用toString() 方法

?

1 2 3 4 5 6 7 8 9 10 11 12

var s1="1",     s2="12abc",     b=true,     o={valueOf:function(){       return -1;       }     };   console.log(++s1);//2 console.log(++s2);//NaN console.log(++b);//2 console.log(++o);//0

2、一元加减操作符

一元加号（+）放在数值前面，对数值不会产生任何影响。

?

1 2	var num=25; num=+num;//还是25

在对非数值应用一元加操作符时，该操作符会像Number()转型函数一样对这个值执行转换。

Number类型的转换规则如下：

（1）如是布尔值，true转换为1，false转换为0

（2）如是null，返回0

（3）如是undefined，返回NaN

（4）如是字符串，规则

• 如字符串中只包含数字（包括前面带正负号的情况），将其转换为十进制数值
• 如字符串中包含有效的浮点格式，将其转换为对应的浮动数值
• 如字符串中包含有效的十六进制格式，例如“oxf”，将其转换为相同大小的十进制整数值
• 如字符串为空，转换为0
• 如字符中包含除上述格式之外的字符，将其转换为NaN

（5）如果是对象，调用对象的valueOf()方法，再依照前面的规则转换返回的值，如果转换结果为NaN，调用对象的toString()方法，再依照前面的规则转换

　

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

var s1="1",     s2="12abc",     s3="0xf",        s4="",        b=true,     f="1.1",     f1="1.1.2",     n=null,        u=undefined,        o={valueOf:function(){       return -1;       }     };   console.log(+s1);//1 console.log(+s2);//NaN console.log(+s3);//15 console.log(+s4);//0 console.log(+b);//1 console.log(+f);//1.1 console.log(+f1);//NaN console.log(+n);//0 console.log(+u);//NaN console.log(+o);//-1

一元减号（-）放在数值前面，会改变数值的正负号。

在对非数值应用一元减操作符时，该操作符与一元加操作符遵循一样的规则，最后再将得到的数值转换为负数。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

var s1="1",     s2="12abc",     s3="0xf",        s4="",        b=true,     f="1.1",     f1="1.1.2",     n=null,        u=undefined,        o={valueOf:function(){       return -1;       }     };     console.log(-s1);//-1 console.log(-s2);//NaN console.log(-s3);//-15 console.log(-s4);//-0 console.log(-b);//-1 console.log(-f);//-1.1 console.log(-f1);//NaN console.log(-n);//-0 console.log(-u);//NaN console.log(-o);//1

　　

3、加法

 加法的操作规则如下：

（1）如果两个操作数都是数值，执行常规的加法计算

• 如有一个操作数是NaN，结果是NaN
• Infinity+Infinity=Infinity
• -Infinity + -Infinity = -Infinity
• Infinity+ -Infinity= NaN
• 0+0=0

（2）如果有一个操作数是字符串：

• 如果两个操作数都是字符串，将两个字符串拼接
• 如果只有一个操作数是字符串，将另一个操作数转换为字符串，然后再将两个字符串拼接

（3）如果有一个操作数是对象、数值或布尔值，则调用它们的toString()方法取得相应的字符串值，在应用上述的字符串规则。对于undefined和null，则分别调用String()函数并取得字符串"undefined"和"null"

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

var r1=5+5; var r3="5"+"5"; var r2="5"+5; var r4=5+"5"; var r5=1+undefined; var r6="1"+undefined; var r7=1+null; var r8="1"+null;   console.log(r1);//10 console.log(r2);//'55' console.log(r3);//'55' console.log(r4);//'55' console.log(r5);//NaN console.log(r6);//'1undefined' console.log(r7);//1 console.log(r8);//'1null'

　　

4、减法

减法的操作规则如下：

（1）如果两个操作数都是数值，执行常规的减法计算

• 如有一个操作数是NaN，结果是NaN
• Infinity-Infinity=NaN
• -Infinity - -Infinity = NaN
• Infinity- -Infinity= Infinity
• -Infinity- Infinity=-Infinity
• 0-0=0

（2）如果有一个操作数是字符串、布尔值、null或undefined，先在后台调用Number()函数将其转换为数值，再计算，如果转换结果是NaN，则结果是NaN

（3）如果有一个操作数是对象，则调用对象的valueOf()方法以取得表示该对象的数值，如果得到的值是NaN，则结果就是NaN。如果对象没有valueOf()方法，则调用toString()方法

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

var r1=5-5; var r3="5"-"5"; var r2="5"-5; var r4=5-"5"; var r5=1-undefined; var r6="1"-undefined; var r7=1-null; var r8="1"-null;<br>var r9=2-"";   console.log(r1);//0 console.log(r2);//0 console.log(r3);//0 console.log(r4);//0 console.log(r5);//NaN console.log(r6);//NaN console.log(r7);//1 console.log(r8);//1<br>console.log(r9);//2

巧用+/-规则转换类型

?

1 2 3 4

var r1=1+""; var r2="1"-0; console.log(r1);//'1'  转换成了字符串 console.log(r1);//1  转换成了数字

5、乘性操作符

3个乘性操作符：乘法、除法、求模

如果参与乘性操作数不是数值，后台会先使用Number()转型函数将其转换为数值。

也就是说空字符串转为0,true转为1，flase转为0

?

1 2 3 4 5 6 7 8 9

var r1=2*null; var r2=2*""; var r3=2*true; var r4=2*undefined;   console.log(r1);//0 console.log(r2);//0 console.log(r3);//2 console.log(r4);//NaN

6、关系操作符　　

关系操作符：<  >   <=   >=

当关系操作符的操作数有非数值时，要进行数据转换，规则如下

（1）如两个操作数都是数值，则执行数值比较

（2）如两个操作数都是字符串，则比较两个字符串对应的字符编码值

（3）如一个操作数是数值，将另一个操作数转换为数值，然后执行数值比较

（4）如果一个操作数是对象，则调用对象的valueOf()方法，再按照上面的规则，如没有valueOf()方法，则调用toString()方法

（5）如一个操作数是布尔值，则先转换为数值，再进行比较，true转换为1，flase转换为0

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

var r1="a">"B"; var r2=1>false; var r3=1>null; var r4=1>undefined; var r5=3>"23"; var r6="3">"23"; var r7="a">2; var r8=3>NaN; var r9=3<NaN;   console.log(r1);//true B的字符编码是66，a的字符编码是97 console.log(r2);//true false-->0 console.log(r3);//true null-->0 console.log(r4);//false undefined-->NaN console.log(r5);//false console.log(r6);//true console.log(r7);//false a-->NaN console.log(r8);//false console.log(r9);//false

　　

7、相等操作符

相等==    不相等 !=    这两个操作符都会先转换操作数，然后再比较它们的相等性   

遵循的规则：

（1）如果有一个操作数是布尔值，比较前先转换为数值，false转为0，true转为1

（2）如果一个操作数是字符串，另一个操作数是数值，比较前先将字符串转换为数值

（3）如果一个操作数是对象，另一个操作数不是，则调用对象的valueOf()方法，

（4）null==undefined

（5）在比较相等性前，不能将null和undefined转换为其他任何值

（6）如果一个操作数是NaN，相等操作返回false，不相等操作返回true 。 NaN不等于NaN

（7）如果两个操作数是对象，则比较它们是不是同一个对象，如果两个操作数都指向同一个对象，则相等操作返回true

?

1 2 3 4 5 6 7 8 9 10 11

console.log(null==undefined);//true console.log(NaN==NaN);//false console.log(NaN!=NaN);//true console.log(false==0);//true console.log(true==1);//true console.log(undefined==0);//false<br>console.log(undefined==false);//false console.log(null==0);//false console.log(null==false);//false console.log("5"==5);//true console.log(new Object() == new Object());//false console.log([1, 2] == [1, 2]);//false

全等===    不全等!==  操作规则　　

类型不同，返回false
类型相同
NaN ≠ NaN
new Object ≠ new Object
null === null
undefined === undefined

?

1 2 3 4 5 6

console.log("1"===1);//false console.log("1"+2===1+"2");//true console.log(1+"2" === "1" + new Number(2));//true  都转成'12' console.log(1+true===false +2);//true console.log(1+null==undefined +1);//false  1+null-->1  undefiend+1-->NaN console.log("a"-"b"=="b"-"a");//false  前后都转成NaN

　　

二、语句中存在的隐式类型转换

1、if语句

if（condition）statement1 else statement2

其中的condition（条件）可以是任意表达式，而且对这个表达式求值的结果不一定是布尔值。

ECMAScript会自动调用Boolean()转换函数将这个表达式结果转换为一个布尔值。

如果对condition求值的结果是true，则执行satement1，如果对condition求值的结果是false，则执行statement2

 

2、while语句

while（expression）statement

do{

　　statement

}while（expression）

同if语句

 

3、for in时的类型转换

定义对象字面量时发生从标识符到字符串的隐式转换。

?

1 2 3 4

var person = {'name':'jack',"age":20,school:'PKU'}; for(var a in person){     alert(a + ": " + typeof a); }

结果：　　

name: string
age: string
school: string

这里name，age分别加单/双引号以强调其为String类型，school没有加单/双引号。我们遍历下该对象的属性，查看其类型。发现school也被隐式的转换成了String类型。

数组的索引其实也是字符串类型。这着实令人惊叹，但事实的确如此。如

?

1 2 3 4

var ary = [1,3,5,7]; for(var a in ary){     alert(a + ": " + typeof a); }

结果：　　

0: string
1: string
2: string
3: string

 

三、alert时存在的隐式类型转换　　

?

1 2 3 4

String.prototype.fn = function(){return this}; var a = 'hello'; alert(typeof a.fn()); //-->object alert(a.fn()); //-->hello

给String原型上添加了个fn方法，该方法返回this，我们知道this可以理解成当前类的实例对象，既然是对象那么typeof a.fn()自然返回是object了。
关键是最后的alert(a.fn())，a.fn()返回的明明是对象，但却隐式的转换成了字符串“hello”显示。

同样的情况发生在数字类型上，如

?

1 2 3 4

Number.prototype.fn = function(){return this}; var a = 10; alert(typeof a.fn());//-->object alert(a.fn()); //-->10

a.fn()返回的是对象类型，但在alert(a.fn())时会隐式的将其转换成数字。