JS 的内置类型

JS 中分为七种内置类型，七种内置类型又分为两大类型：基本类型和对象（Object）。

• 基本类型: null , undefined , boolean , number , string , symbol 。
• 对象: [] , {} 等

判断类型的方法

typeof

操作符返回一个字符串，表示未经计算的操作数的类型。

// 数值
typeof 37 === 'number';
typeof 3.14 === 'number';
typeof NaN === 'number'; // 尽管它是 "Not-A-Number" (非数值) 的缩写
typeof Number(1) === 'number'; // Number 会尝试把参数解析成数值

typeof 42n === 'bigint';
//BigInt 是一种内置对象，它提供了一种方法来表示大于 253 - 1 的整数

// 字符串
typeof 'bla' === 'string';
typeof String(1) === 'string'; // String 将任意值转换为字符串，比 toString 更安全

// 布尔值
typeof true === 'boolean';
typeof Boolean(1) === 'boolean'; // Boolean() 会基于参数是真值还是虚值进行转换

// Symbols
typeof Symbol() === 'symbol';

// Undefined
typeof undefined === 'undefined';
typeof undeclaredVariable === 'undefined'; 

// 对象
typeof {a: 1} === 'object';
typeof [1, 2, 4] === 'object';
typeof new Date() === 'object';
typeof /regex/ === 'object'; // 在 JavaScript中，正则表达式也是对象

// null
typeof null === 'object'

// 函数
typeof function() {} === 'function';
typeof class C {} === 'function'
typeof Math.sin === 'function';

上述例子摘录于MDN,可以看出用typeof判断类型有许多问题,也可以引出几个很有意思的点.

NaN

首先NaN是一个很有意思的类型, NaN不等于它自己.必须使用 Number.isNaN() 或 isNaN() 函数来进行判断。

NaN === NaN;        // false
Number.NaN === NaN; // false
isNaN(NaN);         // true
isNaN(Number.NaN);  // true

// 注意isNaN（）和Number.isNaN（）的区别：如果当前值是NaN，或者将其强制转换为数字后将是NaN，则前者将返回true。而后者仅当值当前为NaN时才为true：

isNaN('hello world');        // true
Number.isNaN('hello world'); // false

其实很好理解,NaN的定义为不是一个数字,而其他类型强制转换为数字类型有时会失败,例如Number('1a') !== Number('2b'),虽然它们各自此时都为NaN,但假如它们转换成功必定是不相等的.

null

null在类型判断时为何会返回object,这和JS最初实现有关,在 JS 的最初版本中，使用的是 32 位系统，为了性能考虑使用低位存储了变量的类型信息，对象的类型标签是 0。而由于 null 代表的是空指针（大多数平台下值为 0x00），因此，null 的类型标签也是0，typeof null 也因此返回 "object"。

object.property.toString.call

MDN中这样描述:为了每个对象都能通过 Object.prototype.toString() 来检测，需要以 Function.prototype.call() 或者 Function.prototype.apply() 的形式来调用，传递要检查的对象作为第一个参数，称为 thisArg。

Object.prototype.toString.call(1) // "[object Number]"
Object.prototype.toString.call(NaN) // "[object Number]"
Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(Symbol()) // "[object Symbol]"
Object.prototype.toString.call(42n) // "[object BigInt]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(true) // "[object Boolean]
Object.prototype.toString.call({a:1}) // "[object Object]"
Object.prototype.toString.call([1,2]) // "[object Array]"
Object.prototype.toString.call(new Date) // "[object Date]"
Object.prototype.toString.call(function(){}) // "[object Function]"

以下是个人理解,不一定正确:

toString() 方法返回一个表示该对象的字符串。

而Object.prototype.toString() 返回的是[object Object],通过 call()或者apply()方法改变了this的指向,指向了对应参数的对象,所以第二个Object变成了参数的类型.

大家可以参考一篇文章:https://juejin.im/post/591647550ce4630069df1c4a

总结

• NaN比较特殊,需要利用Number.isNaN() 或 isNaN() 来判断一个类型是否为NaN
• null因为历史原因会被typeof方法判断为object,可以利用Object.prototype.toString.call(null)来进行正确的判断
• 其中Symbol类型也较为特殊,会另外用一篇博客来学习研究