1. typeof 是否能正确判断类型？

对于原始类型来说，除了 null 都可以调用typeof显示正确的类型。

  1. typeof 1 // 'number'
  2. typeof '1' // 'string'
  3. typeof undefined // 'undefined'
  4. typeof true // 'boolean'
  5. typeof Symbol() // 'symbol'

但对于引用数据类型，除了函数之外，都会显示”object”。

  1. typeof [] // 'object'
  2. typeof {} // 'object'
  3. typeof console.log // 'function'

因此采用typeof判断对象数据类型是不合适的，采用instanceof会更好，instanceof的原理是基于原型链的查询，只要处于原型链中，判断永远为true

  1. const Person = function() {}
  2. const p1 = new Person()
  3. p1 instanceof Person // true
  5. var str1 = 'hello world'
  6. str1 instanceof String // false
  8. var str2 = new String('hello world')
  9. str2 instanceof String // true

2. instanceof能否判断基本数据类型？

能。比如下面这种方式:

  1. class PrimitiveNumber {
  2.   static [Symbol.hasInstance](x) {
  3.     return typeof x === 'number'
  4.   }
  5. }
  6. console.log(111 instanceof PrimitiveNumber) // true

如果你不知道Symbol，可以看看MDN上关于hasInstance的解释。

其实就是自定义instanceof行为的一种方式，这里将原有的instanceof方法重定义，换成了typeof，因此能够判断基本数据类型。

3. 能不能手动实现一下instanceof的功能？

核心: 原型链的向上查找。

  1. function myInstanceof(left, right) {
  2.     //基本数据类型直接返回false
  3.     if(typeof left !== 'object' || left === null) return false;
  4.     //getProtypeOf是Object对象自带的一个方法，能够拿到参数的原型对象
  5.     let proto = Object.getPrototypeOf(left);
  6.     while(true) {
  7.         //查找到尽头，还没找到
  8.         if(proto == null) return false;
  9.         //找到相同的原型对象
  10.         if(proto == right.prototype) return true;
  11.         proto = Object.getPrototypeof(proto);
  12.     }
  13. }

测试:

  1. console.log(myInstanceof("111", String)); //false
  2. console.log(myInstanceof(new String("111"), String));//true

4. Object.is和===的区别？

Object在严格等于的基础上修复了一些特殊情况下的失误，具体来说就是+0和-0，NaN和NaN。

源码如下：

  1. function is(x, y) {
  2.   if (x === y) {
  3.     //运行到1/x === 1/y的时候x和y都为0，
  4.     //但是1/+0 = +Infinity， 
  5.     //1/-0 = -Infinity, 是不一样的
  6.     return x !== 0 || y !== 0 || 1 / x === 1 / y;
  7.   } else {
  8.     //NaN===NaN是false,这是不对的，
  9.     //我们在这里做一个拦截，x !== x，
  10.     //那么一定是 NaN, y 同理
  11.     //两个都是NaN的时候返回true
  12.     return x !== x && y !== y;
  13.   }
  14. }

Object.prototype.toString

Object.prototype.toString.call
获取this指向的那个对象的[[Class]]属性的值。（这也是我们为什么要用call改变this指向的原因）