JS原型链与instanceof底层原理

一、问题:

instanceof 可以判断一个引用是否属于某构造函数;

另外,还可以在继承关系中用来判断一个实例是否属于它的父类型。

老师说:instanceof的判断逻辑是: 从当前引用的proto一层一层顺着原型链往上找,能否找到对应的prototype。找到了就返回true。

如果没有发生继承关系,这个逻辑自然是没有疑惑的。

但是,利用原型继承,切断了原来的prototype的指向,而指向了一个新的对象,这时instanceof又是如何进行判断的呢?

本文通过代码与画图分析instanceof的底层原理,借此复习原型链的知识。


二、instanceof底层是如何工作的:


function instance_of(L, R) {//L 表示左表达式,R 表示右表达式 

    var O = R.prototype;   // 取 R 的显示原型 

    L = L.__proto__;  // 取 L 的隐式原型

    while (true) {    

        if (L === null)      

             return false;   

        if (O === L)  // 当 O 显式原型 严格等于  L隐式原型 时,返回true

             return true;   

        L = L.__proto__;  

    }

}

三、案例:未发生继承关系时


 function Person(name,age,sex){
 
     this.name = name;
 
     this.age = age;
 
     this.sex = sex;
 
 }
 
 function Student(score){
 
     this.score = score;
 
  }
 
 var per = new Person("小明",20,“男”);
 
 var stu = new Student(98);
 
 console.log(per instanceof Person);  // true
 
 console.log(stu instanceof Student);  // true
 
 console.log(per instanceof Object);  // true
 
 console.log(stu instanceof Object);  // true

1、下图1是未发生继承关系时的原型图解:

图1 未发生继承关系时的原型图解

2、instanceof的工作流程分析

首先看per instanceof Person

 function instance_of(L, R) { // L即per ;  R即Person
 
   var O = R.prototype; //O为Person.prototype
 
   L = L.__proto__;       // L为per._proto_
 
   while (true) {    //执行循环
 
        if (L === null)   //不通过
 
            return false;   
 
        if (O === L)       //判断:Person.prototype ===per._proto_?
 
             return true;  //如果等于就返回true,证明per是Person类型
 
        L = L.__proto__;                   
 
   }
 
}         

执行per instanceof Person ,通过图示看出 Person.prototype ===per.proto 是成立的,所以返回true,证明引用per是属于构造函数Person的。

接下来再看 per instanceof Object

 function instance_of(L, R) { //L即per ;  R即Object        

    var O = R.prototype;  //O为Object.prototype        
 
    L = L.__proto__;    // L为per._proto_             
 
    while (true) {     //执行循环                   
 
        if (L === null)   //不通过                            
 
            return false;                      
 
        if (O === L)   //Object .prototype === per._proto_?  不成立**
 
             return true;                         
 
         L = L.__proto__;   //令L为 per._proto_ ._proto_ ,**
 
                         //即图中Person.prototype._proto_指向的对象
 
                         //接着执行循环,
 
                         //到Object .prototype === per._proto_ ._proto_  ?
 
                         //成立,返回true
 
          }
 
 }

四、案例:发生继承关系时

 function Person(name,age,sex){
 
     this.name = name;
 
     this.age = age;
 
     this.sex = sex;
 
 }
 
 function Student(name,age,sex,score){
 
     Person.call(this,name,age,sex);  
 
     this.score = score;
 
  }
 
 Student.prototype = new Person();  // 这里改变了原型指向,实现继承
 
 var stu = new Student("小明",20,"男",99); //创建了学生对象stu
 
 console.log(stu instanceof Student);    // true
 
 console.log(stu instanceof Person);    // true
 
 console.log(stu instanceof Object);    // true

1、下图2是发生继承关系后的原型图解

图2 发生继承关系后的原型图解

2、instanceof的工作流程分析

首先看 stu instanceof Student

 
 function instance_of(L, R) { //L即stu ;  R即Student
 
   var O = R.prototype;  //O为Student.prototype,现在指向了per
 
    L = L.__proto__;    //L为stu._proto_,也随着prototype的改变而指向了per
 
    while (true) {    //执行循环
 
          if (L === null)  //不通过
 
              return false;   
 
          if (O === L)    //判断: Student.prototype ===stu._proto_?
 
              return true;  //此时,两方都指Person的实例对象per,所以true
 
          L = L.__proto__;                   
 
      }
 
 } 

所以,即使发生了原型继承,stu instanceof Student 依然是成立的。

接下来看 stu instanceof Person,instanceof是如何判断stu继承了Person

 function instance_of(L, R) { // L即stu ;  R即Person        
 
   var O = R.prototype; // O为Person.prototype     
 
    L = L.__proto__;   //L为stu._proto_,现在指向的是per实例对象
 
    while (true) {   // 执行循环                   
 
       if (L === null)   //不通过                            
 
           return false;                    
 
       if (O === L)    //判断:   Person.prototype === stu._proto_ ?      
 
            return true;   //此时,stu._proto_ 指向per实例对象,并不满足
 
        L = L.__proto__;  //令L=  stu._proto_._proto_,执行循环
 
   }                      //stu._proto_ ._proto_,看图示知:
 
}                        //指的就是Person.prototype,所以也返回true

stu instanceof Person返回值为true,这就证明了stu继承了Person。

stu instanceof Object也是同理的,根据图示即可轻易得出。

五、结论

1、instanceof 的作用

用于判断一个引用类型是否属于某构造函数;

还可以在继承关系中用来判断一个实例是否属于它的父类型。

2、和typeof的区别:

typeof在对值类型number、string、boolean 、null 、 undefined、 以及引用类型的function的反应是精准的;但是,对于对象{ } 、数组[ ] 、null 都会返回object

为了弥补这一点,instanceof 从原型的角度,来判断某引用属于哪个构造函数,从而判定它的数据类型。

最后,我最近整理了一些IT课程资源,包括慕课网、极客时间等等,入门课、实战课、就业课都有哦,需要学习资源的话可以联系wx: nanke951221
好好学习,升职加薪!

推荐阅读更多精彩内容