原型链模式-基础

首先看基于原型链的构造函数形式：

    function CreateJsPerson(name, age) {
        this.name = name;
        this.age = age;
    }
    CreateJsPerson.prototype.writeJs = function () {
        console.log('my name is ' + this.name + ', age is ' + this.age);
    }
    var p1 = new CreateJsPerson('zhangsan', 20);
    var p2 = new CreateJsPerson('lisi', 30);
    //
    console.log(p1.writeJs === p2.writeJs); // -> true

构造函数模式中拥有了类和实例的概念，并且实例和实例之间是相互独立开来的 -> 实例识别。但是使用这种模式有一个问题，就是writeJs方法相互独立，但是它实现的功能确实相同的，这样就会造成不必要的内存浪费，所以引出了原型链模式，让其功能相同的方法定义在原型链上，使其成为各个实例的公有方法。

1. 基于构造函数模式的原型模式，解决的是方法或者属性公有的问题，把实例之间相同的属性和方法提取成公有的属性和方法 -> 想让谁公有，就把它放在类的prototype上即可。

CreateJsPerson.prototype.writeJs = function () {
        console.log('my name is ' + this.name + ', age is ' + this.age);
    }

1). 每一个"函数数据类型"（普通函数、类）都有一个天生自带的属性: prototype(原型)，并且这个属性是一个对象数据类型的值。
2). 并且在prototype上，浏览器天生给它加了一个属性: constructor(构造函数)，属性值是当前函数(类)本身。
3). 每一个"对象数据类型"（普通的对象、实例、prototype），也天生自带一个属性: __proto__，属性值是当前实例所属类的原型(prototype)

原型链基础.png

2. Object是JavaScript中所有对象数据类型的基类（最顶层的类）。
   1).f1 instanceof Object -> true因为f1通过__proto__可以向上级查找，不管有多少级，最终总能找到Object。
   2). 在Object.prototype上没有proto这个属性。

    function Fn() {
        this.x = 100;
        this.sum = function () {

        }
    }
    Fn.prototype.getX = function () {
        console.log(this.x);
    }
    Fn.prototype.sum = function () {

    }
    var f1 = new Fn();
    var f2 = new Fn();

    console.log(Fn.prototype.constructor === Fn); // -> true; 画图说明
    console.log(f1.__proto__.constructor === Fn); // true; 画图说明

原型基础.png

3. 原型链模式

f1.hasOwnProperty('x'); // hasOwnProperty是f1的一个属性

但是我们发现f1的私有属性上并没有这个方法，那如何处理的并获得这个方法的呢？
1). 通过 "对象名.属性名" 获取属性值的时候，首先在对象的私有的属性上进行查找，如果私有中存在这个属性，则获取的是私有的属性值。
如果私有的没有，则通过__proto__找到所属类的原型(类的原型上定义的属性和方法都是当前实例公有的属性和方法)，如果原型上存在，则获取的是公有的属性值。
如果原型上也没有，则继续通过原型上的__proto__继续向上查找，一直找到Object.prototype为止。
如果Object上也没有，则没有了，返回undefined。
--> 这种查找的机制就是"原型链模式"。

    console.log(f1.getX === f2.getX); // -> true
    console.log(f1.__proto__.getX === f2.getX); // -> true
    console.log(f1.getX === Fn.prototype.getX); // -> true

    console.log(f1.sum === f2.__proto__.sum); // -> false
    console.log(f1.sum === Fn.prototype.sum); // -> false
    console.log(f1.__proto__.sum === Fn.prototype.sum); // -> true

    // f1.hasOwnProperty -> f1.__proto__.__proto__.hasOwnProperty
    // 在IE浏览器中，原型模式也是同样的原理，但是IE浏览器怕你通过__proto__把公有的修改了，禁止我们使用__proto__

f1.sum = function () {
        // 修改/增加的是私有的sum
        // f2不受影响
    }
    f1.__proto__.sum = function () {
        // 所属类原型上的sum
        // 修改/增加的是公有的sum
        // f2受影响
    }
    Fn.prototype.sum = function () {
        
    }