原型思想 内存公用

原型思想:内存公用

由下面的代码看出：

1.fn创建了两个对象f1和f2

2.每个对象都有一个原型对象__proto__

3.由同一个函数创建的对象他们的__proto__共用一个内存 所以相等

        function fn(firstName){
            this.life=1
            this.firstName=firstName
            this.sayName=function(){
                console.log(this.firstName);
            }
        }
        var f1=new fn("张")
        var f2=new fn("李")
        f1.__proto__.age=23//给f1的原型对象添加age:23
        console.log(f2.age,f2);//在f2的原型对象中查找age

函数原型对象prototye

由下面的代码可以看出:

1.每一个函数创建时 都会有一个原型对象prototype被创建

2.每一个函数创建的对象 他的__proto__对象中的值引用自原函数的prototype

原型对象prototype添加元素方法:

fn.prototype.age=23   在fn的prototype中添加了一个成员age=23

         function fn(){
              this.life=1
          }
        //   隐式操作 fn.prototye={}
          function fm(){
              this.color="black"
          }
        //   隐式操作 fm.prototye={}
          var f1=new fn()
          var f2=new fm()

          fn.prototype.age=1
          console.log(fn.prototype);
          console.log(f1.__proto__===f2.__proto__);//proto 引用的是原来的fn fm的prototye所以不是共用空间不相等 
          console.log(f1.__proto__===fn.prototype);//相等

原型对象中添加元素:

由以下代码可知:

new fn()创建新对象并将a和b添加其中

在fm的prototype中创建fn成员并添加new fn()中的元素

最后创建fm对象为f1 打印f1的原型就是打印fm的prototype中的值 也就是new fn（）中的值

        function fn(){
            this.a=20
            this.b=123
        }
        //   隐式操作 fn.prototye={}
        function fm(){
            this.a=30
        }
      

        fm.prototype.fn=new fn()
       //   隐式操作 fm.prototye={fn:{a:20,__proto__:{}}}
        // new fn()==>{__proto__:fn.prototye}==>{a:20,__proto__:{}}


        var f1=new fm()
        console.log(fm.__f1__)