JavaScript中的数据类型

对象类型赋值为对象的引用（地址指针）

let a = {
  name: 'lee',
  age: 18
}
let b = a;
console.log(a.name);  // lee
b.name = 'son';
console.log(a.name);  // son
console.log(b.name);  // son

函数入参为值传递

let a = {
  name: 'Julia',
  age: 20
}
function change(o) {
  o.age = 24;
  o = {
    name: 'Kath',
    age: 30
  }
  return o;
}
let b = change(a);     // 注意这里没有new，后面new相关会有专门文章讲解
console.log(b.age);    // 30 o.name 
console.log(a.age);    // 24 

数据类型检测

1. typeof

   typeof 1 // 'number'
   typeof '1' // 'string'
   typeof undefined // 'undefined'
   typeof true // 'boolean'
   typeof Symbol() // 'symbol'
   typeof null // 'object' typeof null 会输出 object
   typeof [] // 'object'
   typeof {} // 'object'
   typeof console // 'object'
   typeof console.log // 'function'
   

2. instanceof

   let Car = function() {}
   let benz = new Car()
   benz instanceof Car // true
   let car = new String('Mercedes Benz')
   car instanceof String // true
   // instanceof 可以准确地判断复杂引用数据类型，但是不能正确判断基础数据类型
   let str = 'Covid-19'
   str instanceof String // false
   

   代码实现

   function myInstanceof(left, right) {
     // 这里先用typeof来判断基础数据类型，如果是，直接返回false
     if(typeof left !== 'object' || left === null) return false;
     // getProtypeOf是Object对象自带的API，能够拿到参数的原型对象
     let proto = Object.getPrototypeOf(left);
     while(true) {                  //循环往下寻找，直到找到相同的原型对象
       if(proto === null) return false;
       if(proto === right.prototype) return true;//找到相同原型对象，返回true
       proto = Object.getPrototypeof(proto);
       }
   }
   
   // 验证一下自己实现的myInstanceof是否OK
   console.log(myInstanceof(new Number(123), Number));    // true
   console.log(myInstanceof(123, Number));                // false
   

3. Object.prototype.toString

   Object.prototype.toString({})       // "[object Object]"
   Object.prototype.toString.call({})  // 同上结果，加上call也ok
   Object.prototype.toString.call(1)    // "[object Number]"
   Object.prototype.toString.call('1')  // "[object String]"
   Object.prototype.toString.call(true)  // "[object Boolean]"
   Object.prototype.toString.call(function(){})  // "[object Function]"
   Object.prototype.toString.call(null)   //"[object Null]"
   Object.prototype.toString.call(undefined) //"[object Undefined]"
   Object.prototype.toString.call(/123/g)    //"[object RegExp]"
   Object.prototype.toString.call(new Date()) //"[object Date]"
   Object.prototype.toString.call([])       //"[object Array]"
   Object.prototype.toString.call(document)  //"[object HTMLDocument]"
   Object.prototype.toString.call(window)   //"[object Window]"
   

   getType 代码实现

   function getType(obj){
     let type  = typeof obj;
     if (type !== "object") {    // 先进行typeof判断，如果是基础数据类型，直接返回
       return type;
     }
     // 对于typeof返回结果是object的，再进行如下的判断，正则返回结果
     return Object.prototype.toString.call(obj).replace(/^\[object (\S+)\]$/, '$1');  // 注意正则中间有个空格
   }
   
   /* 代码验证，需要注意大小写，哪些是typeof判断，哪些是toString判断？思考下 */
   getType([])     // "Array" typeof []是object，因此toString返回
   getType('123')  // "string" typeof 直接返回
   getType(window) // "Window" toString返回
   getType(null)   // "Null"首字母大写，typeof null是object，需toString来判断
   getType(undefined)   // "undefined" typeof 直接返回
   getType()            // "undefined" typeof 直接返回
   getType(function(){}) // "function" typeof能判断，因此首字母小写
   getType(/123/g)      //"RegExp" toString返回
   

数据类型转换

Number() 方法的强制转换规则

• 如果是布尔值，true 和 false 分别被转换为 1 和 0；
• 如果是数字，返回自身；
• 如果是 null，返回 0；
• 如果是 undefined，返回 NaN；
• 如果是字符串，遵循以下规则：如果字符串中只包含数字（或者是 0X / 0x 开头的十六进制数字字符串，允许包含正负号），则将其转换为十进制；如果字符串中包含有效的浮点格式，将其转换为浮点数值；如果是空字符串，将其转换为 0；如果不是以上格式的字符串，均返回 NaN；
• 如果是 Symbol，抛出错误；
• 如果是对象，并且部署了 [Symbol.toPrimitive] ，那么调用此方法，否则调用对象的 valueOf() 方法，然后依据前面的规则转换返回的值；如果转换的结果是 NaN ，则调用对象的 toString() 方法，再次依照前面的顺序转换返回对应的值（Object 转换规则会在下面细讲）。

Boolean() 方法的强制转换规则

这个方法的规则是：除了 undefined、 null、 false、 ‘’、 0（包括 +0，-0）、 NaN 转换出来是 false，其他都是 true。

’==’ 的隐式类型转换规则

• 如果类型相同，无须进行类型转换；
• 如果其中一个操作值是 null 或者 undefined，那么另一个操作符必须为 null 或者 undefined，才会返回 true，否则都返回 false；
• 如果其中一个是 Symbol 类型，那么返回 false；
• 两个操作值如果都为 string 和 number 类型，那么就会将字符串转换为 number；
• 如果一个操作值是 boolean，那么转换成 number；
• 如果一个操作值为 object 且另一方为 string、number 或者 symbol，就会把 object 转为原始类型再进行判断（调用 object 的 valueOf/toString 方法进行转换）。

’+’ 的隐式类型转换规则

‘+’ 号操作符，不仅可以用作数字相加，还可以用作字符串拼接。仅当 ‘+’ 号两边都是数字时，进行的是加法运算；如果两边都是字符串，则直接拼接，无须进行隐式类型转换。

除了上述比较常规的情况外，还有一些特殊的规则，如下所示。

• 如果其中有一个是字符串，另外一个是 undefined、null 或布尔型，则**调用 toString() 方法(为字面量)**进行字符串拼接；如果是纯对象、数组、正则等，则默认调用对象的转换方法会存在优先级（下一讲会专门介绍），然后再进行拼接。
• 如果其中有一个是数字，另外一个是 undefined、null、布尔型或数字，则会将其转换成数字进行加法运算，对象的情况还是参考上一条规则。
• 如果其中一个是字符串、一个是数字，则按照字符串规则进行拼接。

Object 的转换规则

对象转换的规则，会先调用内置的 [ToPrimitive] 函数，其规则逻辑如下：

按优先级调用,不是则进行下一个。

• 如果部署了 Symbol.toPrimitive 方法，优先调用再返回；
• 调用 valueOf()，如果转换为基础类型，则返回；
• 调用 toString()，如果转换为基础类型，则返回；
• 如果都没有返回基础类型，会报错。

'123' == 123   // true
'' == null    // false
'' == 0        // true
[] == 0        // true
[] == ''       // true
[] == ![]      // true
null == undefined //  null == undefined
Number(null)     // 0
Number('')      // 0
parseInt('');    // NaN
{}+10           // [object Object]10
let obj = {
    [Symbol.toPrimitive]() {
        return 200;
    },
    valueOf() {
        return 300;
    },
    toString() {
        return 'Hello';
    }
}

console.log(obj + 200); // 400

[1,2,undefined,4,5] + 10  // 数组中的 undefined 视为''