要点

1、所有的引用类型（数组、函数、对象）可以自由扩展属性（除null以外）。

2、所有的引用类型都有一个’_ _ proto_ _'属性(也叫隐式原型，它是一个普通的对象)。

3、所有的函数都有一个’prototype’属性(这也叫显式原型，它也是一个普通的对象)。

4、所有引用类型，它的’_ _ proto_ _'属性指向它的构造函数的’prototype’属性。

5、当试图得到一个对象的属性时，如果这个对象本身不存在这个属性，那么就会去它的’_ _ proto_ _'属性(也就是它的构造函数的’prototype’属性)中去寻找。
【当对象属性不存在就会去他隐原型找，但是隐原型指向了构造函数的显示原型，所以去构造函数的显式原型中找】
constructor：所有 prototype 都有一个 constructor 属性指向关联的构造函数

image.png

原文地址

原型

先来看一个原型的例子。

        //这是一个构造函数
        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

在这里插入图片描述

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

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

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

JS 创建的对象都有一个_proto_属性，_proto_属性连接实例和构造函数的原型对象，对外不可见(隐式原型），无法直接获得，可以通过Object.getPrototypeOf（）方法得到这个属性
所有构造器的prototype都是object类型，但是function的prototype是一个空函数，且所有构造器（内置对象）的_proto_指向这个空函数。

console.log(typeof Person.prototype)// object
console.log(typeof Object.getPrototypeOf(person1))// object
console.log(Function.prototype) // f(){}
console.log(typeof Function.prototype)// Function
console.log(typeof Object.prototype)// object
console.log(typeof Array.prototype)// object
console.log(typeof Number.prototype)// object
console.log(typeof Date.prototype)// object
console.log(typeof String.prototype)// object
console.log(typeof Boolean.prototype)// object
 
console.log(Object.getPrototypeOf(Boolean))// f(){}

原型的作用是什么？
原型的作用，就是共享方法。
我们通过 Person.prototype.say 可以共享方法，不会反复开辟存储空间。
.

原型中this的指向是什么？
指向实例化对象p1、p2

函数对象
__proto__：所有引用类型（函数，数组，对象）都拥有__proto__属性（隐式原型）
prototype：所有函数拥有 prototype 属性（显式原型）（仅限函数）
constructor：所有 prototype 都有一个 constructor 属性指向关联的构造函数

当我们声明一个function关键字的方法时，会为这个方法添加一个prototype属性，指向默认的原型对象，并且此prototype的constructor属性也指向方法对象。此二个属性会在创建对象时被对象的属性引用。

function Hello() {}; // 构造函数
var h = new Hello();  // 实例化对象

// 构造函数有个prototype属性
console.log(Hello.prototype); // Object {}  原型对象
// 构造函数的prototype属性有个constructor属性，指向构造函数本身
console.log(Hello.prototype.constructor === Hello); // true


// 实例化对象没有prototype属性
console.log(h.prototype); // undefined
// 实例化对象的constructor属性指向构造函数本身
console.log(h.constructor === Hello); // true
// 即
console.log(h.constructor === Hello.prototype.constructor); // true 


console.log(h.__proto__ === Hello.prototype); // true  
// 即
console.log(h.__proto__ === h.constructor.prototype); //true
// 即
console.log(Hello.prototype === h.constructor.prototype); //true