1. instanceof 从操作符原理及实现

    用于判断构造函数 constructor 的原型 prototype 属性是否出现在对象的原型链上

    1. function myInstanceof (object, constructor) {
    2.   // 错误处理不完善
    3.   if (typeof constructor !== 'function') {
    4.     throw new Error('constructor type error')
    5.   }
    6.   let getPrototype
    7.   if (Object.getPrototypeOf) {
    8.     getPrototype = Object.getPrototypeOf
    9.   } else {
    10.     getPrototype = function (obj) {
    11.       return obj.__proto__
    12.     }
    13.   }
    14.   let proto = getPrototype(object)
    15.   while(proto) {
    16.      if (proto === constructor.prototype) {
    17.        return true
    18.      }
    19.      proto = getPrototype(proto)
    20.   }
    21.   return false
    22. }
    1. 为什么 0.1 + 0.2 !== 0.3，如何让其相等

    计算机存储的的是二进制数据，0.1 和 0.2 在二进制中是无限循环小数（注意是二进制内的），而由于 JS 的标准是 IEEE 754 ，只能使用 64 位二进制数，且只能保留小数部分 52 位精度，剩余的会舍去，因此 0.1 + 0.2 二进制相加，结果之后转为十进制就是 0.30000000000000004

    1. Number.EPSILON ```javascript function compareFloat(f1, f2) { return Math.abs(f1 - f2) <= Number.EPSILON }
    2.    2. 化为整数
    3. ```javascript
    4. function trans(num) {
    5.   let res
    6.   let powerOf10 = 0;
    7.   while(!Number.isInteger(num)) {
    8.     num *= 10
    9.     powerOf10 += 1
    10.   }
    11.   return [num, powerOf10]
    12. }
    13. // [3, 1]
    1. 化为字符串 ```javascript function trans(num) { let numStr = String(num) let [integer, decimal] = numStr.split(‘.’) return [Number(integer), Number(decimal)] }

    // [0, 3] ```

    1. 如何获取安全的 undefined，为什么？

    undefined 只是一个标识符，并不是关键字，因此可以用来做变量和赋值，为了保证兼容性后续版本的 JS 也是这么做的，但这样会影响对 undefined 的判断，因此可以用 void xx 的返回结果，为 undefined
    void 操作符并不改变表达式，只让表达式不返回值，因此一般使用 void 0
    取得 undefined

    1. void 0
    1. typeof NaN 的结果是？

    是 ‘number’，用于指出数字类型中出错的情况（注意不是溢出或精度问题），指“执行数学运算未成功，失败后返回的结果”
    注意 NaN !== NaN，是一个自反的值