简单理解javascript中的原型和原型链

今天理解了js中的原型和原型链相关的知识，在此做一下简单的记录。

其中有几个关键点需要记录：

所有的引用类型（数组，函数，对象）都可以自由拓展属性（null除外）。
所有的引用类型都有一个”proto“属性（也叫做隐式原型，是一个普通对象，指向生成该对象的原函数(构造函数)的原型对象）。
所有的函数都有一个"prototype"属性（也叫做显示原型，是一个普通对象，指向该函数的原型对象）。
所有的引用类型，它的"proto"属性与它的构造函数的”prototype“属性指向的是同一个事物，即原型对象。
当我们试图得到一个对象的一个属性的时候，假如该对象中不包含该属性，那么会顺着它的”proto“属性寻找，或者是它的构造函数的”prototype“属性中寻找。

原型（简单介绍）

该截图中的代码是使用原型模式创建的对象。

image.png

它的对应的在浏览器控制台输出如下：

image.png

细节都尽量写在了注释中，其中，该原型的简单原理图如下：

image.png

简单解释：
代码中，创建一个Person函数，此时，该函数中就会存在一个prototype属性，该属性直接指向该原型对象。此时该原型对象中除了一些自定义的对象之外还存在一个constructor属性，该属性指向该原型对象对应的构造函数。此时，new出来了一个新的person1对象，该对象内部存在一个proto属性，该属性和prototype一样，指向原型对象。这大致就是简单的原型解释。

这个时候，我们来看一个原型的例子：

        function Foo(name,age){
            this.name=name;
            this.age=age;
        }
        /*根据要点3，所有的函数都有一个prototype属性，这个属性是一个对象
        再根据要点1，所有的对象可以自由扩展属性
        于是就有了以下写法*/
        Foo.prototype={
            // prototype对象里面又有其他的属性
            showName:function(){
                console.log("I'm "+this.name);//this是什么要看执行的时候谁调用了这个函数
            },
            showAge:function(){
                console.log("And I'm "+this.age);//this是什么要看执行的时候谁调用了这个函数
            }
        }
        var fn=new Foo('小明',19)
        /*当试图得到一个对象的属性时，如果这个对象本身不存在这个属性，那么就会去它
        构造函数的'prototype'属性中去找*/
        fn.showName(); //I'm 小明
        fn.showAge(); //And I'm 19

这就是原型，很好理解。那为什么要使用原型呢？

试想如果我们要通过Foo()来创建很多很多个对象，如果我们是这样子写的话：

       function Foo(name,age){
            this.name=name;
            this.age=age;
            this.showName=function(){
                console.log("I'm "+this.name);
            }
            this.showAge=function(){
                console.log("And I'm "+this.age);
            }
        }

那么我们创建出来的每一个对象，里面都有showName和showAge方法，这样就会占用很多的资源。
而通过原型来实现的话，只需要在构造函数里面给属性赋值，而把方法写在Foo.prototype属性(这个属性是唯一的)里面。这样每个对象都可以使用prototype属性里面的showName、showAge方法，并且节省了不少的资源。

原型链

理解了原型，那么原型链就更好理解了。

下面这段话可以帮助理解原型链

根据要点5，当试图得到一个对象的属性时，如果这个对象本身不存在这个属性，那么就会去它构造函数的’prototype’属性中去寻找。那又因为’prototype’属性是一个对象，所以它也有一个’_ _ proto_ _'属性。

那么我们来看一个例子

        // 构造函数
        function Foo(name,age){
            this.name=name;
            this.age=age;
        }
        Object.prototype.toString=function(){
            //this是什么要看执行的时候谁调用了这个函数。
            console.log("I'm "+this.name+" And I'm "+this.age);
        }
        var fn=new Foo('小明',19);
        fn.toString(); //I'm 小明 And I'm 19
        console.log(fn.toString===Foo.prototype.__proto__.toString); //true
        
        console.log(fn.__proto__ ===Foo.prototype)//true
        console.log(Foo.prototype.__proto__===Object.prototype)//true
        console.log(Object.prototype.__proto__===null)//true

是不是觉得有点奇怪？我们来分析一下。

image.png

首先，fn的构造函数是Foo()。所以：
fn._ _ proto _ === Foo.prototype
又因为Foo.prototype是一个普通的对象，它的构造函数是Object，所以：
Foo.prototype. _ proto _ _=== Object.prototype
通过上面的代码，我们知道这个toString()方法是在Object.prototype里面的，当调用这个对象的本身并不存在的方法时，它会一层一层地往上去找，一直到null为止。

所以当fn调用toString()时，JS发现fn中没有这个方法，于是它就去Foo.prototype中去找，发现还是没有这个方法，然后就去Object.prototype中去找，找到了，就调用Object.prototype中的toString()方法。

这就是原型链，fn能够调用Object.prototype中的方法正是因为存在原型链的机制。

另外，在使用原型的时候，一般推荐将需要扩展的方法写在构造函数的prototype属性中，避免写在_ _ proto _ _属性里面。

感谢这位csdn中的大神提供的思路与代码还有讲解，许多我是copy过来的，在这里附上他的链接：
https://blog.csdn.net/qq_36996271/article/details/82527256
这就是对原型和原型链的简单理解，一等去看一下视频介绍，再加深一下对这个的理解。

简单理解javascript中的原型和原型链