JS学习笔记之原型链和利用原型实现继承详解

本文实例讲述了js学习笔记之原型链和利用原型实现继承。分享给大家供大家参考，具体如下：

原型链

原型链是一种关系，实例对象和原型对象之间的关系，关系是通过原型(__proto__)来联系的

实例对象中有__proto__,是对象,叫原型,不是标准的属性,浏览器使用,并且有的游览器不支持
构造函数中有prototype属性,也是对象,叫原型

注意 原型中的方法是可以互相访问的

实例代码

 function animal(name,age){
    this.name=name;
    thia.age=age;
   }

   //在原型中添加方法
   animal.prototype.eat=function(){
    console.log("动物吃草")
    this.play()
   }
   animal.prototype.play=function(){
    console.log("玩啥呢")
   }

原型的简单语法  

利用原型共享数据

第一种 写法

 function student(name,age,sex){
      this.name=name;
      this.age=age;
      this.sex=sex;
   }
  
   student.prototype.height="188"
   student.prototype.weight="55kg"
   student.prototype.study=function(){
      console.log("好好学习i")
    }
  var stu=new student("小红",20,"男")
  console.dir(stu)

结果

第二种 写法

 function student(name,age,sex){
      this.name=name;
      this.age=age;
      this.sex=sex;
   }
  student.prototype={
    height:"188",
    weight:"55kg",
    study:function(){
      console.log("好好学习i")
    }
   }
  var stu=new student("小红",20,"男")
  console.dir(stu)

结果

我们会发现 两种写法还是有差别的  ，第二种写法会导致constructor构造器属性消失 所以我们得手动修改构造器指向

最终代码

function student(name,age,sex){
      this.name=name;
      this.age=age;
      this.sex=sex;
   }
  student.prototype={
    constructor:student,
    height:"188",
    weight:"55kg",
    study:function(){
      console.log("好好学习i")
    }
   }
  var stu=new student("小红",20,"男")
  console.dir(stu)

好了,这回有了

实例对象使用属性或方法的规则

实例对象使用的属性或方法,现在实例中查找,如果有则使用自身的属性或方法，
如果没有，则通过__proto__指向的原型对象 查找方法，找到则使用,
如果找不到则继续向__proto__寻找，直到未找到时报错

构造函数和实例对象和原型对象之间的关系

     构造函数可以实例化对象
     构造函数中有一个属性叫prototype,是构造函数的原型对象
     构造函数的原型对象(prototype)中有一个constructor 构造器，这个构造器指向的就是自己所在的原型对象所在的构造函数
     实例对象的原型对象(__proto__) 指向的是该构造函数的原型对象(prototype)
     构造函数的原型对象(prototype)中的方法是可以被实例对象直接访问

改变原型是否可以改变?

首先我们得知道构造函数和实例对象中的this 指向的是什么

这里我创建了自定义构造函数 person ,并在内部输出了this 

并且在person 的原型对象上添加了一个eat 方法，也输出了一个this，

接着我实例化了一个对象，并调用eat方法，

我们执行一下，查看结果如何

输出结果

由此得出

原型对象中方法中的this 就是实例对象

构造函数中的this就是实例对象

接下来我们尝试改变一下原型的指向

这段代码中，首先我定义了一个person自定义构造函数，并且在原型上添加了一个eat方法

定义了一个student 函数，在原型上定义了一个sayhi方法，

然后我将 student的原型指向 了一个 person的实例对象

接着实例化一个student，接着分别在stu 实例上 尝试着调用 eat方法 和 sayhi 方法，

运行结果

到此我们可以确定，stu实例对象的原型指向被下面这条代码改变了

student.prototype=new person(10);

总结

原型指向可以被改变的

实例对象的原型__proto__指向的是该对象所在的构造函数的原型对象

构造函数的原型对象(prototype)指向如果改变了，实例对象的原型(__proto__)指向也会发生改变

实例对象和原型对象之间的关系是通过__proto__ 原型来联系起来的，这个关系就是原型链

如果原型指向改变了，那么就应该再原型改变指向之后添加原型方法

那么sayhi方法则会创建在 new person(10) 这个实例对象上

原型最终指向了哪里

实例对象中的__proto__指向的是构造函数的prototype

以此代码为例

测试一下

所以

per实例对象的__proto__ ---指向--->  person.prototype的__proto__  ---指向--->  object.prototype的__proto__ 是null

查看了一下html的dom对象，这有很有意思的原型链

这里祭出祖传jpg

实现继承

小知识---->instanceof的判断方法:

从左边操作数的__proto__路线出发，从右边操作数的prototype出发，如果两条路线最终指向一个引用就是true了

1.利用 call 借用构造函数继承

优点:实现了继承属性，但值都不相同

缺点: 无法继承父级类别中原型上的方法

function person(name,age,sex,weight){
  this.name=name;
  this.age=age;
  this.sex=sex;
  this.weight=weight;
}
person.prototype.sayhi=function(){
  console.log("您好")
}

function student(name,age,sex,weight,score){
  //将当前实例对象传入person 借过来使用一次来达到继承效果
  person.call(this,name,age,sex,weight);
  this.score=score;
}

var stu1=new student("小明",10,"男","10kg","100")

2.  prototype 实现继承

利用prototype，将student 的prototype 指向 person 来达到继承效果,

优点：继承了父级原型上的方法

缺点:   实例化多个student 都必须共用相同的name 和 age 

student.prototype.constructor=student

注意:   使用原型继承时，需要将构造器的指向更改回正确的指向

function person(name,age){
    this.name=name;
    this.age=age;
   }

   person.prototype.eat=function(){
    console.log("person 吃饭")
   }

   function student(num,score){
    this.num=num
    this.score=score
   }
   //继承
  student.prototype=new person("小红",10)
  student.prototype.constructor=student

  var stu =new student(2016002288,80)

  stu.eat()//person 吃饭

3.组合继承

组合继承其实就是结合了上述的两种方法来实现继承，拥有两种方法的优点

function person(name,age,sex){
    this.name=name;
    this.age=age;
    this.sex=sex;
   }
   person.prototype.sayhi=function(){
    console.log("你好")
   }

   function student(name,age,sex,score){
    //借用构造函数
    person.call(this,name,age,sex)
    this.score=score
   }

   // 改变了原型指向
   student.prototype=new person();//不传值
   student.prototype.eat=function(){
    console.log("吃东西");
   }

   var stu=new student("小黑",20,"男","100分")
   console.log(stu.name,stu.age,stu.sex,stu.score);
   stu.sayhi()//你好
   stu.eat()//吃东西

4.拷贝继承

类似于复制，把一个对象中的属性和方法直接复制到另一个对象中

function person(){
  }

  person.prototype.name="小红"
  person.prototype.age=18

  function student(){
  }
  
  var p=person.prototype;
  var s=student.prototype;

  for(key in p){
    s[key]=p[key]
  }

  console.dir(student)

console

每次都要for in 好累 ,  可以进行优化封装一下

function extend(child,parent) {

　　　　var p = parent.prototype;
　　　　var c = child.prototype;

　　　　for (var i in p) {
　　　　　　c[i] = p[i];
　　　　　　}
    
    //这个属性直接指向父对象的prototype属性,可以直接调用父对象的方法,为了实现继承的完备性，纯属备用性质
　　　　c.par = p;

　　}

5. 直接继承prototype

优点 : 效率比较高

缺点 : 因为相当于是个传址过程 所以修改student的属性 person 的也会被更改 

  function person(){};

  person.prototype.name="小红";
  person.prototype.age=18;

  function student(){};

  student.prototype=person.prototype;

  console.dir(student);
  console.dir(person);
  student.prototype.age=25;

console

6.利用空对象作中介实现继承

用这种方式修改 student 的prototype 不会影响到 person的prototype

function person(){};
  person.prototype.name="小红";
  person.prototype.age=11;

  function student(){};
  var f=function(){};
  f.prototype=person.prototype;

  student.prototype=new f();
  student.prototype.constructor=student;

  student.prototype.age=25;

  console.dir(person)
  console.dir(student)

console

封装一下

function extend(child,parent) {

　　　　var f = function(){};

　　　　f.prototype = parent.prototype;

　　　　child.prototype = new f();

　　　　child.prototype.constructor = child;

　　　　child.par = parent.prototype;

　　}

更多关于javascript相关内容还可查看本站专题：《javascript面向对象入门教程》、《javascript错误与调试技巧总结》、《javascript数据结构与算法技巧总结》、《javascript遍历算法与技巧总结》及《javascript数学运算用法总结》

希望本文所述对大家javascript程序设计有所帮助。