JavaScript稳扎原型模式与构建函数（动态）

原型模式

1. 什么是原型？

我们已经知道，当一个函数(暂且叫son函数)的外层函数(father函数)执行结束后，JS引擎会为son函数创建两个相关的对象，分别是
son本身的函数对象 和 son的原型对象。并且这两个对象之间通过属性constructor和prototype相互关联。
当通过new创建对象时，这个对象中的constructor属性 和 proto属性分别会指向 函数对象 和 原型对象。
> 原型模式中的“原型”就是函数的原型对象。

2. 原型的特点

每个函数初始化完成后都会创建一个原型对象，即：函数对象和原型对象一一对应； 通过new创建的所有对象，都有一个proto属性指向其原型对象；

3. 原型能做什么？

正因为原型对象拥有3.2所提高的两个特点，因此它可以存储某一类型的共有属性和方法。
这样每个对象就不必重复定义函数了，并且能实现某些属性共享。

4. 如何往原型中添加属性？

我们知道，每个通过构造函数的函数对象都有一个prototype属性，指向它的原型对象，因此我们可以使用这个属性访问构造函数的原型对象，并为它添加属性和方法，就像这样：

Person.prototype.getName = function(){
    return this.name;
}
Person.prototype.school = "NJUPT";

注意1：虽然对象中也有个proto属性指向原型对象，但这个属性是提供给JS引擎使用的，我们没办法通过代码访问。
注意2：在原型中添加的属性和函数将会被该类型的所有对象共享；
注意3：原型中的函数的this指向

5. 如何使用原型中的属性？

• 5.1. 访问原型属性

在对象中使用原型属性和使用对象的普通属性一样，不需要任何额外操作：

var person = new Person("柴毛毛",18);
alert(person.school);

当访问person.school时，JS引擎首先从从person对象中找，若找不到，就顺着proto属性去原型中找。

• 5.2.修改原型属性（基本数据类型）

对象无法修改原型中的任何属性！
若原型对象中有school属性，此时执行下列代码，只会在person对象中添加一个school属性，不会对原型属性有任何影响。

person.school = “BJUPT”; 当再次访问person.school时，访问到的就是对象中的school。
只有delete person.school后才能再次访问到原型中的school。
PS：将person.school设为null、undefined并没什么卵用，person.school的结果将仍然是person对象中的school。

• 5.3. 修改原型属性（引用类型）

若原型对象中存在引用类型的属性，那么可以通过对象修改它：

Person.prototype.names = [“chai”,“mao”]; person.names.push(“柴毛毛”);
此时，原型中的names将变成[“chai”,”mao”,”柴毛毛”]，并且该类型所有对象的names都将改变。

6. 定义方式

使用原型模式，首先得创建一个构造函数，然后在构造函数的原型对象上添加属性。

function Person () {}
Person.prototype.属性名 = 属性值；
Person.prototype.函数名 = function(){
  }  

7. 对象创建方式

var person = new Person();

• 优点： -由于原型对象被同一类型的所有对象共享，因此可以将函数 和 共享变量 定义在原型上，从而能避免重复创建对象，节约内存空间，并且能实现变量的共享。
• 缺点 也正是因为原型拥有被同一类型的所有对象共享的特点，因此如果将所有属性都定义在原型上，那么就不存在对象的实例属性了

二、 构造函数+原型模式

通过构造函数创建的对象只有实例属性，没有共享属性；而通过原型模式创建的对象只有共享属性，没有对象的实例属性；因此可以把这两种模式结合起来，取长补短。

1. 定义方式

实例属性在构造函数中定义： 从而每个对象都有各自不同的实例属性值； 共享属性在原型中定义：
从而函数、需要共享的属性可以被同一类型的所有对象共享。 // 在构造函数中定义实例属性

function Person (name,age){
    this.name = name;
    this.age = age;
}

// 在原型上定义函数
Person.prototype.getName = function(){
    return this.name;
}
Person.prototype.getAge = function(){
    return this.age;
}

// 在原型上定义共享的属性
Person.prototype.school = "NJUPT";

2. 对象创建方式

var person = new Person(“柴毛毛”,18);

• 优点

这种模式结合了构造函数模式和原型模式的优点：

可以知道对象的类型； 可以避免函数对象被重复定义，节约内存； 可以添加共享属性；

• 缺点

这种模式唯一的缺点就是打破了封装性 在面向对象的语言中，一个类所有的函数和属性都定义在类中；而这种方式定义的“类”中，函数 和 共享属性
都被定义在了“类”的外面，因此破坏了面向对象的封装性。

三. 构造函数+原型模式PRO（动态原型模式）

这种方式就是为了解决上面方法“破坏了封装性”的问题的。

1. 定义方式

// 在构造函数中定义实例属性
function Person (name,age){
    this.name = name;
    this.age = age;

    if ( typeof this.getName != "function" ) {
        // 在原型上定义函数
        Person.prototype.getName = function(){
            return this.name;
        }

        Person.prototype.getAge = function(){
            return this.age;
        }

        // 在原型上定义共享的属性
        Person.prototype.school = "NJUPT";   
    }
}

上述方式把一个“类”中所有的属性都在“类”内部定义，因此体现了面向对象的“封装性”。
当创建Person类的第一个对象时，就会执行到这个if语句块；由于此时Person的原型中并没有任何自定义的属性，因此typeof
this.getName将返回”undefined”，而不是”function”，因此就会执行if语句块中的代码；这些属性就会被添加到原型对象中；
当第二次创建Person类的对象时，由于原型中已经存在了先前定义的属性，因此typeof
this.getName就会返回”function”，从而if语句块就不会执行。
问题1:可以使用this.prototype来给原型添加属性吗？
绝对不可以！你的代码若要显示访问原型中的属性，只能通过“构造函数.prototype.xxx”去访问，因为prototype属性只存在于构造函数对象中，实例对象中并没有prototype属性。
此外，实例对象中有一个指向原型对象的proto属性，但这个属性只给JS引擎使用，我们通过代码是调用不到的！这个属性的作用是：当我们通过实例对象调用原型中的属性时，JS引擎就会使用这个指针通往原型对象。
问题2:用this.getName来判断原型对象中是否有getName函数合理吗？是否可以用Person.prototype.getName来判断？
这里有两个问题，第一个问题：完全合理。第二个问题：完全可以。下面分别解释。
我们知道，通过构造函数创建对象后，内存中会有三个与之相关的对象：1.构造函数本身的对象A、2.构造函数的原型对象B、3.实例对象C。
构造函数中的this指向实例对象C，因此当执行this.getName时，JS引擎首先在对象C中找，而C刚创建，肯定不会有getName函数，因此JS引擎通过proto属性去原型B中找。

2. 对象创建方式

var person = new Person(“柴毛毛”,18);

优点：和原型模式+构造函数模式相比，增加了封装性，更利于理解代码。
缺点：一般都用这种方法，完美无缺点！

 一般来说，定义“类”就使用原型模式，先前介绍的几种方式都是为了引出原型模式。

##下面介绍几种在特殊情况下会用到的定义“类”的模式

1. 寄生构造函数模式

当我们要给JS原生对象扩充功能的时候，我们可以在原生对象的原型上添加新功能，由于原型上的属性被该类所有对象共享，因此我们就可以在旧对象上使用新功能。但这种做法太危险，假设现在你系统的Array类中没有distinct函数，然后你在Array.prototype上添加了个distinct函数；当你的系统扩展后，也许那个JS库中也向Array.prototype添加了个distinct函数，那你先前添加的那个函数将被覆盖掉，调用这个函数的代码将会出错。因此，不要向原生对象的prototype中添加任何属性！
但如果想要扩展原生对象的功能，就可以使用寄生构造函数模式。

1.1 定义方式

function MyArray () {
    var array = new Array();

    array.distinct = function () {
        // ……
    }

    array.sort = function () {
        // ……
    }

    return array;
}

• 定义方式和工厂模式类似：

手动new一个需要扩展的原生JS对象； 在这个对象上添加新功能； 返回这个对象。

1. 1.2 调用方式

方式一：直接调用

var array = MyArray();

方式二(推荐)：使用new

var array = new MyArray();

为了体现它是一个对象创建的过程，增强可读性，因此建议你仍然使用new来创建对象，那有人不禁要问：这个构造函数违背了构造函数的规则呀，不仅显示创建了一个对象，还显示调用了return语句，难道new调用它仍能正确执行吗？
当然可以！通过new执行一个函数时，JS都会首先创建一个对象，再执行函数中的代码，最后如果没有return语句，就会自动return刚才创建的那个对象；如果有return语句，那么就返回return后面指定的对象。
因此，在这里通过new调用MyArray时，JS引擎会创建一个默认的Object对象，并且将它的proto、constructor分别指向MyArray.prototype和MyArray，然后执行自身的代码。谁知在执行自身代码的过程中又创建了个新对象，并且给新对象添加了属性，最后还返回了这个对象。因此，通过这种模式创建的对象，它的proto、constructor仍然指向Array，因此它的类型是Array，而非MyArray。

• 优点： 可以在不影响原生对象的基础上增强原生对象的功能
  因为这种模式在原生“类型”的对象上添加新功能，而非在原生“类型”的原型上添加，因此不会对原型造成任何影响。
  此外，由于创建的对象是原生类型，因此又具有原生类型的所有功能。 这种模式在扩充原生类型的功能方面堪称完美！
• 缺点：
  没办法知道对象的确切类型，只能知道它的原生对象类型。 稳妥构造函数模式

由于this、new等关键字会导致安全漏洞的发生，因此若系统安全性要求很高的话就不能使用这些语法，此时若要创建对象就得使用稳妥构造函数模式。

方法定义

function Person ( name, age ) {
    var object = new Object();
    // object.name = name;
    // object.age = age;
    object.getName = function(){
        return name;
    }
    object.getAge = function(){
        return age;
    }
    return object;
}

• 注意这里被注掉的两行代码，对于安全级别较高的属性，不能直接挂载到object对象上(因为直接挂载到object上的属性可以被外界随意修改和访问)，而是让它们以局部变量的形式出现在构造函数中，若外界要访问和修改，则在object上添加访问和修改的函数，这样就可以在函数中对修改作限制。
  我们知道，函数的局部变量存在于函数的变量对象中，一旦函数执行完成，变量对象中的值只能通过函数内部的闭包来访问。

  这是JS语法糖，是为了写起来方便而添加的新语法本质上仍然是使用new Object创建对象。