数据类型转换

强制类型转换

包括Number()、parseInt()、parseFloat()、toString()、String()、Boolean()，这几种方法都比较类似。

Number()

如果是数字，返回自身
如果是布尔值，true为1,false为0
如果是null，返回0
如果是undefined，返回NaN
如果是字符串，遵循以下规则：只包含数字（或者是0x/0X开头的十六进制数字，也可包含正负号，也可包含小数点），则将其转换成十进制；空字符串，转换为0；不是以上格式的，返回NaN

如果是对象，首先调用对象的valueOf方法，如果转换为基础类型，然后依据前面的规则转换返回的值；如果valueOf方法没有转换为基础类型，会继续调用toString()方法，再次依照前面的规则转换返回对应的值

const obj1 = {
    valueOf() {
        return 2
    },
    toString() {
        return 3
    }
}
const obj2 = {
    toString() {
        return 3
    }
}
const obj3 = {
    valueOf() {
        return 'aaa'
    },
    toString() {
        return 3
    }
}
console.log(Number(obj1))   //2
console.log(Number(obj2))   //3
console.log(Number(obj3))   //NaN

toString()与valueOf讲解参照：https://www.cnblogs.com/lianglanlan/p/15033978.html

parseInt()

parseInt(string, radix)

parseInt第二个参数可以改变数字的进制。相关链接：不同进制的转换

如果string不是字符串，会调用toString()方法转换为字符串。

如果是数字，返回数字整数部分
如果是布尔值/null/undefined，返回NaN
如果是字符串：
- 以数字开头（或者是0x/0X开头的十六进制，也可包含正负，也可包含小数点），则返回整数部分
- 以数字外的字符开头，返回NaN
```
parseInt('12')      //12
parseInt('0x123')   //291
parseInt('12a')     //12
parseInt('a12')     //NaN
parseInt('-12.23')  //-12
```

如果是对象，直接调用toString()方法，再依照前面的规则返回对应的值

const obj1 = {
    valueOf() {
        return 2
    },
    toString() {
        return 'a3'
    }
}
const obj2 = {
    toString() {
        return '3a'
    }
}
const obj3 = {
    valueOf() {
        return 'aaa'
    },
    toString() {
        return 3
    }
}
console.log(parseInt(obj1))   //NaN
console.log(parseInt(obj2))   //3
console.log(parseInt(obj3))   //3

parseFloat()

与parseInt()同理

toString()

数字、布尔值、字符串直接返回变量的字符串格式
null/undefined调用报错
如果是对象，返回'[object Object]'
如果是数组，返回arr.join(',')
如果是函数，返回字符串式函数体

String()

其余值与toString()返回一致。

可以将null和undefined转换为字符串。

Boolean()

除了undefined/null/false/''/0/NAN转换出来是false，其余都是true

隐式类型转换

==

如果类型相同，无须进行类型转换
如果其中一个操作值为null或undefined，那么另一个操作符必须为null或undefined 才会返回true，否则为false
```
console.log(undefined == null)  //true
console.log(undefined == '')    //false
```
两个操作值如果为string和number类型，那么会将string转换为number
```
console.log('' == 0)    //true
console.log('123' == 123)   //true
```

两个操作值如果为boolean和number类型，那么会将boolean转换为number

console.log(false == 0)     //true
console.log(true == 1)      //true
console.log(true == 123)    //false

两个操作符为object和string/number，会将object转换为原始类型（先调用valueOf()再调用toString()）

var a = {
    value: 0,
    valueOf: function () {
        this.value++
        return this.value
    }
}

console.log(a == 1 && a == 2 && a == 3) //true

+

数字相加、字符串拼接。

两边都是数字时，进行加法运算，没有类型转换
两边都是字符串时，直接拼接，无需类型转换
如果其中一个是字符串、一个是数字，则按照字符串规则进行拼接
```
console.log(1 + '1')    //'11'
```

如果其中一个是字符串，另一个是undefined/null/boolean，调用String()进行字符串拼接。

console.log('1' + undefined)    //'1undefined'
console.log('1' + null)         //'1null'
console.log('1' + true)         //'1true'

如果另一个是对象/数组，则先调用valueOf再调用toSring()方法将对象转换为简单类型再进行字符串拼接

const obj = {
    a: 1
}
const obj1 = {
    valueOf() {
        return 2
    },
    toString() {
        return 3
    }
}
const obj2 = {
    toString() {
        return 3
    }
}
const obj3 = {
    valueOf() {
        return 'aaa'
    },
    toString() {
        return 3
    }
}

console.log('1' + obj)      //'1[object Object]'
console.log('1' + obj1)     //'12'
console.log('1' + obj2)     //'13'
console.log('1' + obj3)     //'1aaa'

const arr = [1, 2]
console.log('1' + arr)  //'11,2'
//arr.toString() = '1,2'

如果其中有一个是数字，另外一个是undefined/null/boolean，则会将其转为数字进行加法运算

console.log(1 + undefined)    //NaN
console.log(1 + null)         //1
console.log(1 + true)         //2

如果另一个是对象/数组，则先调用valueOf再调用toSring()方法将对象转换为简单类型再进行加法运算

const obj = {
    a: 1
}
const obj1 = {
    valueOf() {
        return 2
    },
    toString() {
        return 3
    }
}
const obj2 = {
    toString() {
        return 3
    }
}
const obj3 = {
    valueOf() {
        return 'aaa'
    },
    toString() {
        return 3
    }
}

console.log(1 + obj)      //'1[object Object]'
console.log(1 + obj1)     //3
console.log(1 + obj2)     //4
console.log(1 + obj3)     //'1aaa'