js 原型对象

构造函数的缺点

  • js 通过构造函数生成新对象 
    function OutFun (name,gender){
      this.name=name
      this.gender=gender
  }

  var fun = new OutFun('小明','女')
  console.log(fun.name)
  • OutFun函数是一个构造函数，OutFun函数内部定义了name属性和gender属性。实例对象上都会有这两个属性，
  • 属性定义到实例上，但有一个缺点。就是同一个构造函数的多个实例之间是无法共享属性。造成资源的浪费
    function OutFun (name,gender){ this.name=name this.gender=gender this.innerFun = function (){ console.log('this') } } var fun = new OutFun('小明','女') var fun1 = new OutFun('小明','女') console.log(fun.innerFun===fun1.innerFun)//false
  • 可以看出fun和fun1虽然是同一个构造函数但其实是两个实例。他们实例上都有innerFun 。我们每实例化的时候就创建一个新的innerFun。那怎么共享innerFun？那么就用到下面的原型对象prototype了

原型对象prototype

  • js继承，就是原型对象中的所有属性和方法，都能被实例对象共享。js中每一个函数都有prototype，prototype其实就是一个object。 
      console.log(typeof OutFun.prototype)//object

    • 对于普通函数，prototype没有太大作用。但对于构造函数，生成实例的时候该属性会自动成为实例对象的原型。

       function OutFun(){
    this.age='33'
  }
  OutFun.prototype.name='小明'
  OutFun.prototype.age='44'
  var fun=new OutFun()
  console.log(fun.name)//小明
  console.log(fun.gender)//undefined
  console.log(fun.age)//33

    • 我们在访问name属性的时候。实例对象上没有该属性或方法,它就回去原型对象去找该属性或方法.若实例对象上有则不去原型对象上找。若原型对象上也没有该属性和方法。那么就去原型的原型找，还找不到就去原型的原型的原型找，直到找到Object.prototype还没有，就返回undefined
      注意，要找某个属性会一级级向上，对性能也是有影响的。这就意味着，如果这个属性根本不存在，那么我们就得再整条原型链里查找一边。对性能的开销也越大。

    • 原型对象:定义实例对象共享的属性和方法。

原型链

  • 原型链：js中所有对象都有自己的原型对象（prototype）。任何对象都可以充当其他对象的原型。原型本身也是对象，所以它也有自己的原型。那么就形成了---原型链（对象，对象的原型，对象原型的原型……）
    对象的原型最终到Object.prototype（null）。所有对象都可以继承原型（prototype）上的属性

       Object.getPrototypeOf(Object.prototype)//null

    Object.getPrototypeOf方法返回参数对象的原型

image.png

eg：让构造函数中原型对象指向一个数组，这就意味着我们这个实例对象就可以使用数组的方法

      function OutFun(){}
      OutFun.prototype=new Array()
      var fun = new OutFun()
      fun.push(1,2,3)
      console.log(fun.length)//3
      console.log(fun instanceof Array)//true--------------------instanceof 判断一个对象是否为某个构造函数的实例

instanceof运算符

  • 判断一个对象是否为某个构造函数的实例
  • X instanceof S -----------------------X对象，S构造函数。instanceof 检查右边S构造函数的原型对象（prototype），是否在左边对象的原型链上。
    于S.prototype.isPrototypeOf(X)一样。
        function OutFun(){}
        var fun=new OutFun()
        console.log(fun instanceof OutFun)//true----表示该fun实例对象是OutFun构造函数的实例
  • instanceof检查整条原型链，同一个实例对象，可能会对多个构造函数都返回true。
        var arr=new Array()
        console.log(arr instanceof Array)//true
        console.log(arr instanceof Object)//true
  • 任意对象（null除外）都是Object的实例，所以instanceof运算符可以判断是否为非null
        var obj = { name: 'xiaoming' };
        var arr = new Array()
        console.log(obj instanceof Object)// true
        console.log(null instanceof Object)// false
        console.log(arr instanceof Object)// true
  • instanceof运算符只能用于对象，不适用基本数据类型的值
        var num = 2342;
        console.log(num instanceof Number) // false

        var str = '2342';
        console.log(str instanceof Number) // false

        var isTrue = true
        console.log(isTrue instanceof Number) // false

        var und = undefined
        console.log(und instanceof Number) // false
  • 利用instanceof运算符，解决调用构造函数时，忘了加new命令的问题。
    function Fubar (foo, bar) {
            if (this instanceof Fubar) {//this是否是构造函数的实例，如果不是则没有new
                this._foo = foo;
                this._bar = bar;
            } else {
                return new Fubar(foo, bar);
            }
        }

constructor 属性

  • prototype对象有一个constructor属性，默认指向prototype对象所在的构造函数。
        function OutFun(){}
        //默认指向prototype所在的构造函数--可知道我们要想知道这个实例对象是那个构造函数产生的
        console.log(OutFun.prototype.constructor===OutFun)//true
        //改变OutFun的原型对象，那么constructor的指向也跟着改变了---constructor属性表示原型对象与构造函数之间的关联关系，如果修改了原型对象，会同时修改constructor属性，防止引用的时候出错。
        OutFun.prototype=new Array()
        console.log(OutFun.prototype.constructor===OutFun)//false
        //手动改变constructor
        OutFun.prototype.contructor=OutFun
        console.log(OutFun.prototype.constructor===OutFun)//false
  • 既然constructor是prototype的属性，那么表示constructor可以被所有实例对象继承
  • 我们可以从constructor调用构造函数。相当于调用自身的构造函数。
        function OutFun(){}
        var fun=new OutFun()
        var funCon = new fun.constructor()
        console.log(funCon instanceof OutFun)//true
  • 通过name属性，从实例得到构造函数的名称。
        function OutFun(){}
        var fun=new OutFun()
        console.log(fun.constructor.name)//OutFun

构造函数的继承

  • 子类是整体继承父类
  1. 第一步是在子类的构造函数中，调用父类的构造函数。
  2. 第二步，是让子类的原型指向父类的原型，这样子类就可以继承父类原型。
  //首先我们先定义父类
        function Parent(){
            this.num = 0
        }
        Parent.prototype.sum = function(num){
            this.num +=num
        }
        //子构造函数
        function Son(){
            Parent.call(this)//调用父类构造函数
        }
        Son.prototype = Object.create(Parent.prototype)//子类继承父类的原型
        Son.prototype.constructor = Son
        var son = new Son()
        son.sum(3)
        son.sum(5)
        console.log(son.num)
  • 子继承父类的单个方法
    //定义父类
        function Parent(){
            this.num = 0
        }
        Parent.prototype.sum = function(num){
            console.log(num,'num')
            this.num += num
        }
        //子构造函数
        function Son(){
            Parent.call(this)//调用父类构造函数
        }
        Son.prototype.sum=function(){
            Parent.prototype.sum.call(this,3)
        }
        var son = new Son()
        son.sum()
        son.sum()
        console.log(son)//6
        console.log(son instanceof Son)//false
        console.log(son instanceof Parent)//false
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • JS原型对象、原型链和继承
    1、理解Object和Function Object和Function都是引用类型，是一种数据结构，封装数据和功能...
    小笨郎阅读 646评论 0赞 1
  • JS之原型对象
    每当创建一个新函数，都会依据一些规则为其创建一个prototype属性，该属性指向函数的原型对象。原型对象默认有一...
    晴天的晴q阅读 366评论 0赞 1
  • js原型对象（一）
    为什么要写原型对象？ 原型，其实已经是前端知识中老生常谈的内容了。很多初学者和工作者其实都觉得这个概念其实跟你使用...
    古朋阅读 558评论 1赞 7
  • js原型对象与原型链
    首先我们要先了解几个概念，js万物皆对象，所有类型（对象，函数，数组...）都有一个属性 proto，只有函数才有...
    李柏成_Burc阅读 233评论 0赞 0
  • js的原型对象
    原型对象：每创建一个函数，该函数就会自动带有一个 prototype 属性。该属性是个指针，指向了一个对象，我们称...
    Shi_wen阅读 110评论 0赞 0

友情链接更多精彩内容