1. // 方法一：
    2. // 变量 R 的原型是否存在于变量 L 的原型链上；
    3. function instance_of(L, R) {
    4.     // 若变量 R 为基本数据类型，直接返回 false
    5.     const baseType = ['string', 'number', 'boolean', 'undefined', 'symbol']
    6.     if(baseType.includes(typeof(L))) return false;
    8.     let RP = R.prototype; // 取 R 的显示原型
    9.     L = L.__proto__; // 取 L 的隐式原型
    11.     while(true) {
    12.         if(L === null) return false; // 此时找到最顶层了
    13.         if(L === RP) return true;
    15.         L = L.__proto__; // 没找到时，继续向上一层原型链查找
    16.     }
    17. }
    18. console.log(instance_of({}, Object))
    20. // 方法二：
    21. function myInstanceof(L, R) {
    22.     // 若变量 R 为基本数据类型，直接返回 false
    23.     const baseType = ['string', 'number', 'boolean', 'undefined', 'symbol']
    24.     if(baseType.includes(typeof(L))) return false;
    26.     // 获取实例对象原型
    27.     let proto = Object.getPrototypeOf(L);
    28.     // 获取构造函数的 prototype 对象
    29.     let prototype = R.prototype;
    31.     // 判断构造函数 R 的 prototype 对象是否在对象 L 的原型链上
    32.     while(true) {
    33.         if (!proto) return false
    34.         if (proto === prototype) return true
    36.         // 如果没有找到，就继续从其原型上找
    37.         // Object.getPrototypeOf方法用来获取指定对象的原型（内部[[Prototype]]属性的值）
    38.         proto = Object.getPrototypeOf(proto);
    39.     }
    40. }
    42. console.log(myInstanceof('', Object))

    解析如下代码，证明 万物皆对象：

    1. function Foo(name) {
    2.   this.name = name;
    3. }
    4. var f = new Foo('chen');
    6. f instanceof Foo; // true
    7. f instanceof Object; // true

    上述代码的判断流程大致如下：

    1. f instanceof Foo：f的隐式原型 __proto__ 和 Foo.prototype 是相等的，所以返回 true；
    2. f instanceof Object：f的隐式原型 __proto__ 和 Object.prototype 是不等的，所以继续往上走。f的隐式原型 __proto__ 指向 Foo.prototype，所以继续用 Foo.prototype.__proto__去对比 Object.prototype，此时是相等的，因为 Foo.prototype就是一个普通的对象。