Javascript 基础之类型

内置类型

js 中内置类型一共 7 种（包括 es6），7 种内置类型可分为两大类型：基本类型 和 引用类型（对象Object)。

1.基本类型包括：null、undefined、string、number、boolean、symbol。

重点说下数字类型number：

js 中数字类型是浮点类型的，没有整型。浮点类型基于 IEEE 754 标准实现，在使用中会有 bug；
NaN 也属于 number 类型，并且 NaN 不等于自身；

2.对象（Object）是引用类型，在使用过程中会遇到 浅拷贝 和 深拷贝 的问题。

const x = { name: 'x'};
const y = x;
y.name = 'y';
console.log(x.name); // y

typeof 应用

1.对于基本类型，除了 null 都可以显示正确类型

typeof x;        // 'undefined'
typeof '1';      // 'string'
typeof 1;        // 'number'
typeof true;     // 'boolean'
typeof Symbol(); // 'symbol'

typeof 1 也可以写成 typeof(1)，其他也是一样。

2.对于对象，除了函数都显示object

typeof [];          // 'object'
typeof {};          // 'object'
typeof console;     // 'object'
typeof console.log; // 'function'

3.说说 null，一个遗留 bug，明明是基本类型，可是就显示 object

typeof null ;   // 'object'

那为什么会出现这种情况呢？
js 最初版本中，使用的是 32 位系统，为了性能考虑使用低位存储变量的类型信息，000 开头表示对象，而 null 表示全零，所以将它错判为 object 了。虽然现在内部类型的判断代码变了，但是这个 bug 却一直流传下来。

4.正确获取变量类型可使用 Object.prototype.toString.call(xx)，获得类似 [object Type] 的字符串

Object.prototype.toString.call(111)

类型转换

1.转Bollean

除了 undefined、null、false、NaN、''、0、-0，其他都为 true，包括对象。

2.对象转基本类型

对象转基本类型时，会调用 valueOf、toString 两个方法，也可以重写 Symbol.toPrimitive (优先级最高)

let p = {
  valueOf(){
    return 0;
  },
  toString(){
    return '1';
  },
  [Symbol.toPrimitive] (){
    return 2;
  }
}
console.log(1 + p);  // 3
console.log('1' + p);  // 12

3.四则运算符

只有加法运算符时，一方是字符串类型，就会把另一方也转为字符串类型;
其他运算只要其中一方是数字，那么另一方就转为数字;
加法运算符会触发3钟类型转换：将值转换为原始值，转换为数字，转换为字符串。

console.log(1 + '1'); // 11
console.log(1 * '1'); // 1
console.log([1, 2] + [1, 2]); // '1, 21, 2'
// [1, 2].toString() => '1, 2' 
// [1, 2].toString() => '1, 2' 
// '1, 2' + '1, 2' => '1, 21, 2'

加号有个需要主要的表达式 'a' + + 'b'

console.log('a' + + 'b');   // aNaN
//  + 'b' => NaN

4.`==` 操作符

比较运算 x == y，其中 x 和 y 是值，产生 true 或 false：

（1）.Type(x) 与 Type(y) 相同，则

Type(x) 为 undefined，返回 true;
Type(x) 为 null，返回 true;
Type(x) 为 number，则
- x 为 NaN，返回 false（NaN == NaN）;
- y 为 NaN，返回 false（NaN == NaN）;
- x 与 y 相等数值，返回 true;
- x 为 +0，y 为 -0，返回 true;
- x 为 -0，y 为 +0，返回 true;
Type(x) 为 string，则当 x 与 y 为完全相同的字符序列（长度相等且相同字符在相同位置）时返回 true，否则 false（'11' == '21'）。
Type(x) 为 boolean，x 与 y 同为 true 或同为 false，返回true;

（2）.x 为 null 且 y 为 undefined，返回 true，互换也是;

（3）.若 Type(x) 为 number 且 Type(y) 为 string，返回 comparison x = toNumber(y) 的结果，互换也是；

（4）.Type(x) 为 boolean，返回 toNumber(x) = y（ 5 > 3 == 1）,互换也是;

（5）.Type(x) 为 string 或 number，且 Type(y)为 object，返回 x = toPrimitive(y) 的结果，互换也是；

注：toPrimitive 对象转基本类型

有个烧脑的例子：

console.log( [] == ![] ); // true
// 从右往左解析， [] => true => 取反 => false => [] = false
// 根据第(4)条，toNumber(false) => 0
// 根据第(5)条，toPrimitive([]) == 0 => [].toString() => ''
// 根据第(3)条，toNumber('') == 0 => 0 == 0

总结：对象-布尔（字符串）-数字

5.运算符

如果是对象，通过 toPrimitive 转为对象；
如果是字符串，通过 unicode 字符索引来比较；

下一篇: Javascript 基础之原型和原型链