day16 类型转换

1、显示类型转换

a. Number ( mix )

转换成数字

±true  // ±1
±false // 0
"ture"  "false" // NaN
null , " " , [ ]  // 0  
undefined // NaN

b. parseInt ( string , radix )

变成整型数字,非四舍五入
重点不是转成数字 重点是整型(提取数字)

 true , false  -- >  parseInt ( String(ture) ) --> NaN

把数字当成基底(radix:2~36)进制的数，转化成十进制数。如下，把’‘a’'当成16进制的数，转化成十进制是10.

 var num = parseInt ("a",16); 
 console.log(num); // 10   

例：

console.log(parseInt(3,8)); // 3    
console.log(parseInt(3,2)); // NaN     
console.log(parseInt(3,0)); // 3/NaN 

c. parseFloat（string）

变成浮点型

console.log(parseFloat( 100.2.3 ));  // 100.2

d. String ( mix )

变成字符串

e. Boolean ( mix )

变成布尔值

Boolean( [ ] )  // true
null, undefined, "", false, 0, NaN  // false

f. toString ( radix )

转成字符串（undefined/null 不能用）

把十进制数转化成目标进制的数：

var demo = 10;
var num = demo.toString (8);
console.log (num); // 12

进制转换：2 - 10 -16

var demo = 10101010;
var num = parseInt(demo,2);
var num2  = num.toString(16);
console.log(num2);

g. toFixed ( num )

科学计数法 保留几位小数 四舍五入

var num = 123.36;
console.log ( num.toFixed(1) ); // 123.4

2、隐式类型转换

a. isNaN

隐式进行Number（），跟 NaN比对 返回true/false)

console.log(isNaN(undefined)); 
Number (undefined ) // NaN   ----> true
console.log(isNaN(null)); 
Number ( null )    //   0  -----> false

b. ++    - -     *     /     %     + \ - （一元正负）

先隐式调用Number ( )，然后进行运算，无法转成数字的依旧转成数字类型输出NaN

var num = "abc";
num ++;
console.log(num); // NaN

var num = + "123";
console.log(typeof(num) + ":" + num);   //  number : 123

c.  +

两侧有一个字符串 就调用String();

var a = "a" + 1; 
console.log(a); // a1

d. &&     ||     ！

判断的时候隐式调用类型转换Boolean( )

e.  <     >     <=    =>

如果是数字与字符串比较，会把字符串隐式转成数字类型，在再转换成Boolean返回值。

var num = "3" > 2;
console.log(num); // true

var num = true > false;
console.log(num); // true

var num = 2 > 1 > 3;
console.log(num); // true ( 1 ) > 3  ---> false

var num = 2 > 1 > 3;
console.log(num); // true ( 1 ) > 3  ---> false

undefined > 0;  undefined < 0;   undefined ==0;   // false
null > 0;       null< 0;         null ==0;	 // false
undefined == null  // true

f.   ==     !=

 NaN == NaN  // false

g. ===

 ===   //绝对等于
！==   //绝对不等于
NaN === NaN // false