显隐式数据类型判断

一：显式类型转换

1. Boolean() 转化值类型：

1. 转化为false的参数类型：

false, undefined, null, NaN, '', +0, -0 这些值都被Boolean(value)转为false；

         Boolean() 转化的情况如下代码所示：

    // 以下转化为false的案例
    console.log(Boolean(false)); 
    console.log(Boolean(undefined));
    console.log(Boolean(0));
    console.log(Boolean(null));
    console.log(Boolean(''));
    console.log(Boolean(NaN));
    console.log(Boolean(+0));
    console.log(Boolean(-0));


    // -------------------------
    // 其余转化为true
   console.log(Boolean(1));
   console.log(Boolean({}))  // true
   console.log(Boolean(function(){})) // true
   console.log(Boolean(Symbol(123))) // true

2. Number()进行显示转换;

2.1 number（obj） 转化对象类型的情况

• 一般先去找对象中的valueOf 方法返回值；如果返回值为对象再去找，toString 方法的返回值
• Number('[object Object]') == NAN 如下代码示例

Number(obj) -> obj.valueOf ? {} ? -> obj.toString() -> Number(obj.toString());

// 一：：
var obj = {              
   toString () {
      // return {}  直接报错
     return 1;  
   },
   valueOf () {
     // return {} 如果返回的是引用值则去找toString方法；
     return 2   
   }
 }
 console.log(Number(obj)) // 2

// 二：；
var obj = {              
   toString () {
     return 1;
   },
   
 }
//1 对象中没有ValueOf方法则找toString，若没有则到原型上找toString
 console.log(Number(obj))

// 三：；
var obj = {              
 }
// NaN  对象上toString转为[object Object] 
 console.log(Number(obj))  
// console.log(Number('[object Object]'))  NAN

Number(arr) 转数组 -> arr -> arr.ValueOf（） ? -> arr.toString() -> Number(arr.toString());

 

// [].valueOf() == 数组本身[] 因此去寻找  [].toString() 方法
console.log(Number([])) // 0   [].toString() ==> ''
console.log(Number('')) // 0
Number(false)  // 0
Number(null) // 0
Number ('  ') // 0

Number() 转普通值：

Number('123a') //    => NaN
Number('null') //    => 0
Number('123') //    => 123

3. String() 进行数据类型转换：

1. 原始值进行String() 包装：

        原始值 返回的 都是 字符串类型；

console.log(String(1))  // '1'
console.log(String('1'))  // '1'
console.log(String(false)) // 'false'
console.log(String(null))  // 'null'
console.log(String(undefined))  // 'undefined'
// 总结： 原始值返回的都是字符串类型；

1. 引用数据类型的包装：        

         跟Number()寻找方式相反； String() 先去寻找toString()方法，如果返回是一个引用值再去寻找valueOf() 方法

 

// 一：
var test = {
  toString () {
    return 1
  },
  valueOf () {
    return 2
  },
}
 // 先找toString 如果没有找valueOf  
// 去找原型上的toString()
console.log(String (test))  // log: 1
// 二：
var test = {
  // Object.prototype.toString.call(this)  == [object Object]
  valueOf () {
    return 2
  },
}
console.log(String (test))   // [object Object],
// 三：
var test = {
  toString () {
    return {}
  },
  valueOf () {
    return 2
  },
}
console.log(String (test)) // 2;

包装数组：

const arr = [1,2,[1,2], 3];
console.log(arr.valueOf());  // 本身 [1,2,[1,2], 3]
console.log(arr.toString()); // 1,2,1,2,3

// arr.toString()  == 1,2,1,2,3 ->  String(1,2,1,2,3)
console.log(String(arr)); // 1,2,1,2,3

1. Number（）转进制

number(11)  // 
number(011)  // 2进制
number(0x11) // 16进制

4. parseInt() 数据类型转换：

1. parseInt : 对数字类型的转化

var a = true;
parseInt(a || false) // NAN   - number

parseInt('123a') // 123 -   number
parseInt('a123') // NAN

parseInt(null || undefined)   // NAN
parseInt(1, 16)  // 第二个参数表示进制位

console.log(parseInt('11', 2))   // 转为2进制
console.log(parseInt('11', 16))   // 16进制

1. number.toFIxed（） 保留小数

var a = 3.144
a.toFixed(2)  => //  3.14  四舍五入  保留小数

1. parseFloat()

console.log(parseFloat('3.141412'));
// log: 3.141412
console.log(parseFloat('3.141412aaa'));
// log: 3.141412
console.log(parseFloat('3.14ab526c'));
// log: 3.14

 5. undefined和null：

• undefined 和 null 在 == 的条件下相等
• === 严格下 不相等
• === 严格相等，对数据类型进行检测，还需对值进行检测

    console.log(undefined == null)  // true
    console.log(undefined === undefined)  // true
    console.log(null === null); // true
    console.log(undefined === null); // false

console.log(1 == true)		// 隐式转换  number（）
console.log('1' == true)  // 隐式转换  number（）

console.log([] == ![])   // true  Number()

二：隐式类型转换：

1. > < >= <= 和数字进行比较，1 >= || < || > || <= '1'会把非数字的一方进行Number('1')进行包装
2. 1 - || * || / '1' -> Number('1')
3. 'a' > 'b' || 'a' < 'b' 会通过ASCII码进行比较

var a = 1 > '2' // 会进行 number类型转换  Number(2)
var a = 'a' > 'b' // 对ascii 码进行比较
var a = '3' + 1  // String(1);  '31'
var a = '3'  * 1   // Number('3')  -> 3


var a = '123'
a++;
a--;
--a;
++a;   // 会进行隐式转换
log(a)  //  =>  124 - number
// 
var b = '123a';
++b;  // NaN

console.log(-'1');  // 数字类型 ： -1
console.log(+'1');  // 1

console.log(undefined == null)  // true;
console.log(undefined === null)  // false
console.log(undefined == 0)  // false

console.log(null == 0)  // false
console.log(Number(null) == 0);  // true

isNaN(arg)

会将 isNaN(arg) -> isNaN(Number(arg)) 通过Number（）进行隐式转换

console.log(isNaN(undefined)); // true
console.log(isNaN('abc'));// true

console.log(isNaN(null));// false
console.log(isNaN('1'));// false