做前端开发已经好几年了，技术与工作年限不匹配，自查，将知识点整理出来，自我完善，也希望能帮助到大家。 本内容是参考《JavaScript高级程序（第3版）》。
创建对象
对象的定义：无需属性的集合，其属性可以包含基本值、对象或者函数。
严格来讲，这就相当于说对象是一组没有特定顺序的值。对象的每个属性或方法都有一个名字，而每个名字都映射到一个值。正因为这样，我们可以把对象想象成散列表：无非就是一组名值对，其中值也可以是数据或函数。
每个对象都是基于一个引用类型创建的，这个引用类型可以是原生类型，也可以是开发人员定义的类型。
虽然object构造函数或对象字面量都可以用来创建单个对象，但这些对象有个明显的缺点：使用同一个接口创建很多对象，会产生大量的重复代码（没有办法产生通用的类）。
工厂模式
工厂模式是软件工程领域一种广为人知的涉及模式，这种模式抽象了创建具体对象的过程。在ECMAScript中无法创建类，开发人员发明了一种函数，用函数来封装以特定接口创建对象的细节。
function createPerson (name, age, job) {
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function () {
alert(this.name);
};
return o;
};
let person1 = createPerson('nicholes', 29, 'student');
let person2 = createPerson('Musa', 32, 'IT');
工厂模式虽然解决了创建多个相似对象的问题，但却没有解决对象识别的问题（即怎样知道一个对象的类型）。还有个问题就是对于公共的方法和属性，没有办法共用，造成资源上的一种浪费。
构造函数模式
ECMAScript中的构造函数可用来创建特定类型的对象。像Object 和 Array 这样的原生构造函数，在运行时会走动出现在执行环境中。此外，也可以创建自定义的构造函数，从而定义自定义对象类型的属性和方法。
function Person (name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = function () {
alert(this.name);
}
};
const person1 = new Person('nicholas', 29, 'student');
const person2 = new Person('Musa', 29, 'IT');
在上面的例子中，Person 函数取代了 createPerson 函数，注意到，Person 中的代码除了与createPerson中相同的部分外，不同的地方有：
- 没有显式地创建对象
- 直接将属性和方法赋给了this对象
- 没有return语句。
按照惯例，构造函数始终都应该以一个大写字母开头，而非构造函数则应该以一个小写字母开头。
要创建构造函数的新实例，必须使用 new 操作符。在调用构造函数会经历4个步骤
- 创建一个新对象
- 将构造函数的作用域赋值给新对象（因为this就指向了这个新对象）
- 执行构造函数中的代码（为这个新对象添加属性）
- 返回新对象
创建自定义的构造函数意味着将来可以将它的实例标识为一种特定的类型；而这正是构造函数模式胜过工厂模式的地方。
将构造函数当做函数
构造函数与其他函数的唯一区别，就是在调用的方式不同。构造函数也是函数，不存在定义构造函数的特殊语法。
任何函数，只要通过new操作符来调用，那他就可以作为构造函数；相同，任何函数，不通过new操作符调用，那就跟普通函数没区别。
构造函数的文图
构造函数的主要问题：每个方法都要在每个实例上重新创建以便。也就是说，定义的公共引用类型属性和方法，没有办法共用，每个实例都会创建新的各自的。
我们可以把定义函数转移到构造函数外部。而在构造函数内部，将方法设置成等于全局的方法，这样做解决了不能方法不能复用的问题，可是新的问题是：在全局作用域中定义的函数实际上只能被某个对象调用，这让全局作用域有点名不副实。更无法接受的是：如果对象需要定义很多方法，那么就要定义很多全局函数，我们这个自定义的引用类型就丝毫没有封装性可言了。（这个问题可以通过原型模式来解决）。
原型模式
每个函数都有一个prototype原型属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。
按照字面意思来理解，那么prototype就是通过调用构造函数而创建的那个对象实例的原型对象。
使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。
换句话说，不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中。
function Person () {};
Person.prototype.name = 'Musa';
Person.prototype.age = 29;
Person.prototype.job = "IT";
Person.prototype.sayName = function () {
alert(this.name);
};
let person1 = new Person();
let Person2 = new Person();
person1.sayName === person2.sayName; // true
与构造函数不同的是，新对象的这些属性和方法是由所有实例共享的。
以上面的例子来说，person1 和 person2 访问的都同一组属性和同一个sayName函数。
原型对象
无论什么时候，只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，这个属性指向函数的原型对象。在默认情况下，所有原型对象都会自动活得一个constructor（构造函数）属性，这个属性包含一个指向prototype属性所在函数的指针。
原型最初只包含 constructor 属性，而该属性也是共享的，因此可以通过对象实例访问。
虽然可以通过对象实例访问保存在原型中的值，但却不能通过对象实例重写原型中的值。就是当为对象实例添加一个属性时，这个属性就会屏蔽原型对象中保存的同名属性；
ECMAScript 5的Object.getOwnPropertyDescriptor()方法只能用于实例属性，要取得原型属性的描述符，必须直接在原型对象上调用Object.getOwnProperty-Descriptor()方法。
原型与in操作符
有两种方式使用In操作符：
- 单独使用（单独使用是，in操作符会在通过对象能够访问给定属性时返回true。
'name' in object // true） for-in循环中使用
在使用 for-in 循环时，返回的是所有能够通过对象访问的、可枚举的属性，其中既包括存在于实例中的属性，也包括存在于原型中的属性。屏蔽了原型中不可枚举属性的实例属性也会在for-in循环中返回。
要取得对象上所有可枚举的实例属性，可以使用 Object.keys() 方法。
如果想要得到所有实例属性，无论是否可枚举，都可使用Object.getOwnPropertyNames()方法。
更简单的原型方法
为了减少不必要的输入，也为了从视觉上更好地封装原型的功能，更常见的做法是用一个包含所有属性和方法对象字面量来重写整个原型对象：
function Person () {};
Person.prototype = {
name: 'Musa',
age: 322,
job: 'IT',
sayName: function () {
alert(this.name)
}
}
上面代码中，将Person.prototype设置为对象字面量形式创建的新对象。有个问题，constructor属性不再指向Person。在这里使用的语法，本质上完全重写了默认的prototype对象，因此constructor属性也就变成了新对象的constructor属性，不再指向Person函数。尽管instanceof 操作符还能返回正确的结果，但通过constructor已经无法确定对象的类型了。
如果 constructor的值很重要，可以像下面这样 特意将他设置回适当的值：
function Person () {};
Person.prototype = {
constructor: Person,
...
}
注意：以这种方式重设constructor属性会导致他的[[Enumerable]]特性被设置为true。 默认的情况下，原生的construtor属性是不可枚举的，因此如果使用兼容ECMAScript5的JavaScript引擎，可以试试Object.defineProperty()
function Person () {};
Person.prototype = { ... };
Object.defineProperty(Person.prototype, 'constructor', {
enumerable: false,
value: Person
});
原型的动态性
由于在原型中查找值的过程是一次搜索，因此我们对原型对象所有的任何修改都能够立即从实例上反映出来---即使是先创建了实例后修改原型也照样如此。
var friend = new Person ();
person.prototype.sayHi = function () { alert("hi") };
friend.sayHi(); // hi
其原因可以归结为实例与原型之间的松散连接关系。当我们调用friend.sayHi()时，首先会在实例中搜索名为 sayHi的属性，在没有找到的情况下，会继续搜索原型。因为实例与原型之间的链接只不过是一个指针，而非一个副本，因此就可以在原型汇总找到新的sayHi属性返回保存在那里的函数。
尽管可以随时为原型添加属性和方法，并且修改能够立即在所有对象实例中反应出来，但如果是重写整个原型对象，那么情况就不一样了。我们知道，调用构造函数时回味实例添加一个指向最初原型[[prototype]]指针，而把原型修改为另外一个对象就等于切断了构造函数与最初原型之间的联系，实例中的指针仅指向原型，而不指向构造函数。
原生对象的原型
原型模式的重要性不仅体现在创建自定义类型方面，就连所有原生的引用类型，都是采用这种模式创建的。所有原生引用类型都在骑构造函数的原型上定义了方法。
通过原生对象的原型，不仅可以取得所有默认方法的引用，而且也可以定义新方法。可以像修改自定义对象的原型一样修改原生对象的原型，因此可以随时添加方法。
尽管可以这样做，但我们不推荐在产品化的程序中修改原生对象的原型。如果因某个实现中缺少某个方法，就在原生对象的原型添加这个方法，那么当在另一个支持该方法的视线中运行代码时，就可能出现命名冲突。而且这样做也可能会意外地重写原生方法。
原型对象的问题
首先，他省略了为构造函数传递初始化参数这一缓解，结果所有实例在默认情况下都将取得相同的属性值。虽然这会在某种成都上带来一些不方便，但还不是原型的最大问题。原型模式的最大问题是由其共享的本性所导致的。
原型中所有属性是被很多实例共享的，这种共享对于函数非常合适。对于哪些包含基本值的属性倒也说得过去，毕竟，通过在实力上添加一个同名属性，可以隐藏原型中的对应属性。然而，对于包含引用类型值的属性来说，问题旧表突出了。
function Person () {};
Person.prototype = {
constructor: person,
friends: ['shelby', 'court']
};
const person1 = new Person();
const person2 = new Person();
person1.friends.push('Musa');
console.log(person1.friends); // ['shelby', 'court', 'Musa']
console.log(person2.friends); // ['shelby', 'court', 'Musa']
console.log(person1.friends === person2.friends); // true
假如，我们的初衷就是像这样在所有实例中共享一个数组，那么对这个结果无话可说。可是，实例一般都是要有属于自己的全部属性的。而这个问题正式我们很少看到有人单独使用原型模式的原因所在。
组合使用构造函数模式和原型模式
创建自定义类型的最常见方式，就是组合使用构造函数模式与原型模式。构造函数模式用于定义实例属性，而原型模式用于定义方法和共享属性。结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度地节省了内存。另外，这种混成模式还支持向构造函数传递参数；是集两种模式之长。
function Person (name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.friends = ['shelby', 'court'];
};
Person.prototype = {
constructor: Person,
sayName: function () {
alert(this.name);
}
};
const person1 = new Person('nicholas', 28, 'software');
const person2 = new Person('greg', 25, 'doctor');
person1.friebds.push('Van');
console.log(person1.friends); // ['shelby', 'court', 'Van'];
console.log(person2.friends); // ['shelby', 'court'];
console.log(person1.friends === person2.friends); // false
console.log(person1.sayName === person2.sayName); // true
动态原型模式
有其他OO语言经验的开发人员在看到独立的构造函数和原型时，很可能会感到非常困惑。动态原型模式正式致力于解决这个问题的一个方案，它把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（尽在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说，可以通过检查某个应用存在的方法是否有效，来决定是否需要初始化原型。
function Person (name, age, job) {
// 属性
this.name = name;
this.age = age;
this.job = job;
// 方法
if (typeof this.sayName != 'function') {
Person.prototype.sayName = function () {
alert(this.name);
}
}
}
这里只在sayName 方法不存在的情况下，才会将他添加到原型中。这段diamante只会在初次调用构造函数时才会执行。此后，原型已经完成初始化，不需要再做什么修改。而且，这里对原型所做的修改，能够立即在所有的实例中得到反应。因此，这种方法确实可以说非常完美。其中，if语句检查的可以是初始化之后应该存在的任何属性或方法----不必用一大堆if语句检查每个属性和每个方法；只要检查其中一个即可。对于采用这种模式创建的对象，还可以使用instanceof操作符确定它的类型。
使用动态原型模式时，不能使用对象字面量重写原型。如果在已经创建了实例的情况下重写原型，那么就会切断现有实例与新原型之间的联系。
寄生构造函数模式
通常，在前述的几种模式都不适用的情况下，可以使用寄生构造函数模式。这种模式的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但从表面上看，这个函数又很像典型的构造函数。
function Person (name, age, job) {
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function () {
alert(this.name);
};
return o;
};
const friend = new Person('nicholas', 28, 'IT');
friend.sayName(); // 'nicholas'
在这个例子中，Person 函数创建了一个新对象，并以响应的属性和方法初始化该对象，然后又返回了这个对象。除了使用new操作符并把使用的包装函数叫做构造函数之外，这个模式跟工厂模式是一模一样的。构造函数在不返回值的情况下，默认会返回新对象的实例。通过在构造函数末尾添加一个return语句，可以重写调用构造函数时返回的值。
这个模式可以在特殊的情况下用来为对象创建构造函数。
假设我们想创建一个具有额外方法的特殊数组。由于不能直接修改Array构造函数，因此可以使用这个模式。
function SpecialArray () {
// 创建数组
let values = new Array();
// 添加值
values.push.apply(values, arguments);
// 添加方法
values.toPipedString = function () {
return this.join("|");
};
// 返回数组
return values;
};
const colors = new SpecialArray('red', 'blue', 'green');
alert(colors.toPipedString()); // "red|blue|green"
关于寄生构造函数模式，有一点需要说明：首先，返回的对象与构造函数或者与构造函数的原型属性之间没有关系；也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此，不能依赖instanceof操作符来确定对象类型。由于存在上述问题，建议在可以使用其他模式的情况下，不要使用这种模式。
稳妥构造函数模式
道格拉斯·克罗克福德（Douglas Crockford）发明了JavaScript中的稳妥对象（ durable objects ）这个概念。所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象。稳妥对象最适合在一些安全的环境中（这些环境中会禁止使用this和new），或者在防止数据被其他应用程序（如 Mashup 程序）改动时使用。
稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：一是新创建对象的实例方法不引用this；二是不使用new操作符调用构造函数。
function Person (name, age, job) {
// 创建要返回的对象
var o = new Object();
// 可以在这里定义私有变量和函数
o.sayName = function () {
alert(name);
};
// 返回对象
return o;
};
/* @TODO
* 在这种模式创建的对象汇总，除了使用sayName 方法之外，没有其他办法访问name的值。
* 可以像下面使用稳妥的Person构造函数。
*/
var friend = Person('Nicholas', 29, 'Software');
friend.sayName(); // 'Nicholas'
这样，变量friend中保存的是一个稳妥对象，而除了调用sayName()方法外，没有别的方式可以访问其数据成员。即使有其他代码会给这个对象添加方法或数据成员，但也不可能有别的办法访问传入到构造函数中的原始数据。稳妥构造函数模式提供的这种安全性，使得它非常适合在某些安全执行环境-----例如： ADsafe和Caja提供的环境下使用。
与寄生构造函数模式类似，使用稳妥构造函数模式创建的对象与构造函数之间也没有关系，因此 instanceof操作符对这种对象也没有意义。
