建立对象

JS有六种数据数据范例，个中五种属于基础数据范例：Null、Boolean、undefined、String、Number。
而别的值都是对象。数组是对象，函数是对象，正则表达式是对象。对象也是对象。

来看一下对象的定义：

无序属性的鸠合，其属性能够包括基础值、对象、或许函数。

我们经由历程对象字面量的体式格局 建立对象。建立的对象用于我们想要做的事。然则，假如只要对象，那末能够设想我们写的代码将满是光溜溜的对象，会发生大批的反复代码，和定名争执等等题目。这是异常异常蹩脚的。
为了处理这个题目，人们开始运用 工场情势的一种变体。

工场情势

工场情势笼统了详细对象的历程。也就是说，发清楚明了一种函数，把对象放到函数里，用函数封装建立对象的细节。

function createPerson (name,age) {
    var o = {
        name : name,
        age : age,    
        sayName : function () {
            alert(this.name)
        }
    }
    return o;
}
var person1 = createPerson("Tom",14);
var person2 = createPerson("Jerry",18)

console.log(person1 instanceof Object)  //true
console.log(person1 instanceof createPerson)  //false

instanceof 用于检测数据范例
var aa = []
console.log(aa instanceof Array)  //true

工场情势处理了代码复用的题目，然则却没有处理对象辨认的题目。即建立的一切实例都是Object范例。
为了处理这一题目，就有了组织函数情势

组织函数情势

function Person (name,age) {
    this.name = name;
    this.age = age;
    this.sayName = function () {
        alert(this.name)
    }
}
    var person1 = new Person('Tom',14);
    var Person2 = new Person('Jerry',18);

1. 组织函数 Person 有一个prototype(原型)属性，这个属性是一个指针，指向一个对象即：Person.prototype(原型对象)；
2. 实例person1 person2也有一个[[prototype]]属性或许叫_proto_,这个属性 也指向Person.prototype；
3. 组织函数、和实例 都同享Person.prototype里的 属性和要领；
4. Person.prototype里有一个 constructor属性，这个属性也是一个指针，指向组织函数Person。如许以来，实例 也指向了Person,那末实例 也同享了组织函数的属性和要领。
5. 组织函数、实例、原型对象里一切的属性和要领 都是同享的。

组织函数处理了对象辨认题目，我们在这个例子中建立的对一切对象既是Object的实例，同时，也是Person的实例。这一点经由历程instanceof操纵符能够获得考证。

console.log(person1 instanceof Object)  //true
console.log(person1 instanceof Person)  //true

建立自定义的组织函数意味着，未来能够将它的实例 标识为一种特定范例；这正是组织函数赛过工场情势的处所。Array就是这类体式格局(我以为的)。用组织函数的体式格局，实例化一个新对象，这个对象能够是别的范例比方Array范例。

 function Array () {

 }
 var arr = new Array()
 arr instanceof Array  // true

组织函数与一般函数的区分

组织函数和一般函数的唯一区分，在于挪用它们的体式格局差别。

看成组织函数运用

    function Person (name,age) {
        console.log(this)   
    }
    var person = new Person()

须要注重的是，this 指向 组织函数Person

看成一般函数运用

 function Person (name,age) {
    console.log(this)
 }
 Person()

this指向widow.

组织函数的题目

组织函数虽然好用，但也有缺点。既每一个new出来的实例 里的要领都要从新建立一遍。在前面的例子中person1 person2 都有一个sayName要领，但这两个要领不是同一个Function实例！每一个实例的要领 都是差别的，不相等的。这是不合理的！

function Person (name) {
    this.name = name;
    this.sayName = new Function ("alert(this.name)")
}
function Person (name) {
    this.name = name;
    this.sayName = function () {
        alert(this.name)
    }
}

alert( person1.sayName == person2.sayName )  //false

因而可知，完成一样使命的函数确切没必要 每一个实例，就实例一次。
因而，有需求，就有处理方案。原型情势。

原型情势

我们建立的每一个函数都有一个prototype(原型)属性，这个属性是一个指针，指向一个对象，而这个对象的用处是包括能够由特定范例的一切实例同享的属性和要领。

运用原型对象的长处是能够让一切对象实例同享它所包括的属性和要领。也就是说，没必要在组织函数中定义对象实例的信息，而是将这些信息增加到原型对象中。

废话少说，那末究竟 原型情势是怎样处理 每一个实例的要领 是同一个呢？
看代码：

function Person (){
}
Person.prototype.name = "Tom";
Person.prototype.sayName = function () {
    alert(this.name)
};
或许  
Person.prototype = {
    constructor : Person,
    name : "Tom",
    sayName : function () {
        alert(this.name)
    }
}
var person1 = new Person();
person1.sayName();  //"Tom"

var person2 = new Person();
person2.sayName(); //"Tom"

alert( person1.sayName == persona2.sayName )   //true

再来看下这个：

1. 组织函数 Person 有一个prototype(原型)属性，这个属性是一个指针，指向一个对象即：Person.prototype(原型对象)；
2. 实例person1 person2也有一个[[prototype]]属性或许叫_proto_,这个属性 也指向Person.prototype；
3. 组织函数、和实例 都同享Person.prototype里的 属性和要领；
4. Person.prototype里有一个 constructor属性，这个属性也是一个指针，指向组织函数Person。如许以来，实例 也指向了Person,那末实例 也同享了组织函数的属性和要领。
5. 组织函数、实例、原型对象里一切的属性和要领 都是同享的。

与组织函数比拟，
原型情势，把大众要领提出来放到prototype对象里。
每一个实例 的[[prototype]]指针 指向这个对象，所以一切实例的大众要领 是同一个。如许也避免了内存糟蹋。

原型情势的别的特征

略

概况拜见 《JS高程3》 第六章

原型情势的题目

我们写代码的时刻，很少只用到原型情势，申明它照样有坑的。
原型情势很大的长处 是一切实例都同享属性和要领。这个很好的长处 关于函数来讲异常适宜，可关于属性来讲，有点不适应这类开放的”热忱”。
看代码：

function Person () {
}
Person.prototype = {
    constructor : Person,
    name : "Tom",
    friends : ["Jerry","Sara"]
}
var person1 = new Person();
var person2 = new Person();

person1.friends.push("Vans");

alert( person1.friends ); //"Jerry","Sara","Vans"
alert( person2.friends ); //"Jerry","Sara","Vans"
alert( person1.friends === person2.friends ); //true

以上已很清楚明了了，给一个实例增加属性值，效果，一切实例的属性值也转变了。实例应当具有本身的自力性。本身稀里糊涂的被转变，肯定是有题目标。
有题目，就会有处理方案，再多坑，也抵不过我们先辈的不懈努力。
因而就有了 组织函数和原型情势夹杂情势

组合运用组织函数情势和原型情势

建立自定义范例最常见的体式格局，就是组合情势。

组织函数情势用于定义实例属性，而原型情势用于定义要领和同享的属性。

效果，每一个实例都有本身的一份实例属性的副本。注重是是 副本。同时，又同享着对要领的援用，最大限制地节省了内存。

别的，这类混成情势还支撑向组织函数通报参数。

function Person (name,age) {
    this.name = name;
    this.age = age;
    this.friends = ["Tom","Jerry"]
}
Person.prototype = {
    consructor : Person,
    sayName : function () {
        alert(this.name)
    }
}

var person1 = new Person("Abert",18);
var person2 = new Person("Marry",17);

person1.friends.push("Vans");
alert( person1.friends ); //"Tom","Jerry","Vans"
alert( person2.friends ); //"Tom","Jerry"
alert( person1.friends === person2.friends ); //false

在例子中，实例属性是由组织函数定义的，且每一个实例的属性 是自力的。转变 实例的属性，并不影响别的实例的属性，如许就避免了 原型情势的”狂热的同享热忱”。
一切实例的同享属性和要领 则是在原型中定义的。修正任何实例(person1或person2)中哪个，别的实例 都邑受到影响。由于所以实例的[[prototype]]指针 指向原型对象(Person.prototye)，它们具有配合的援用。组织函数中的实例属性 则只是 副本。

以上就是 工场情势、组织函数、原型情势以及组合情势 各自的特定和区分。
中心都在《JS高程3》。我做了些简朴的梳理，和本身的明白。有不明白或许质疑的处所，以书为准。

总结

什么是工场情势 ？

工场情势就是笼统了详细对象细节历程的要领。这个要领以函数的情势封装完成的细节。完成了反复挪用的功用。

什么是组织函数情势 ？

组织函数情势就是建立一个对象，new 这个对象就是对象的实例。完成反复挪用的同时，它的实例 也有了QQVIP的高贵特权 ，即

实例能够标识为特定的范例。有了这个标识 能够更好的辨认出，谁是数组范例，谁是函数范例，然后你 typeof arr 或 typeof fun

一看，真的是Array范例，functiong范例。你也能够自定义本身想要的范例，如许大大的增加了JS的拓展性。

什么是原型情势 ？

起首我们要知道，我们建立的每一个函数都有一个隐蔽属性，也就是 原型属性。这个原型属性指向一个原型对象。且一切实例和组织函数 都指向这个原型对象，同享 原型对象的一切要领和属性。

我们经由历程操纵原型对象到达 实例同享属性要领的目标，就是原型情势。

同时，由于实例都是援用 原型对象的属性和要领，也避免了组织函数情势下一切实例都有各自的要领的弊病。