创建对象的几种模式

工厂模式：

function createPerson(name, age, job) {

let o = new Object();

o.name = name;

o.age = age;

o.job = job;

o.sayName = function() {

       console.log(this.name);

};

return o;

}

let person1 = createPerson("Nicholas", 29, "Software Engineer");

let person2 = createPerson("Greg", 27, "Doctor");

     

       这种工厂模式虽然可以解决创建多个类似对象的问题，但没有解决对象标识问题（即新创建的对象是什么类型）。

构造函数模式：

       以函数的形式为自己的对象类型定义属性和方法：

      

function Person(name, age, job){  或者  //let Person = function(name, age, job) {

this.name = name;

this.age = age;

this.job = job;

this.sayName = function() {

      console.log(this.name);

};

}

let person1 = new Person("Nicholas", 29, "Software Engineer");

let person2 = new Person("Greg", 27, "Doctor");

person1.sayName(); // Nicholas

person2.sayName(); // Greg

    

要创建 Person 的实例，应使用 new 操作符。以这种方式调用构造函数会执行如下操作。

(1) 在内存中创建一个新对象。

(2) 这个新对象内部的[[Prototype]]特性被赋值为构造函数的 prototype 属性。

(3) 构造函数内部的 this 被赋值为这个新对象（即 this 指向新对象）。

(4) 执行构造函数内部的代码（给新对象添加属性）。

(5) 如果构造函数返回非空对象，则返回该对象；否则，返回刚创建的新对象。

       

console.log(person1.constructor == Person); // true

console.log(person2.constructor == Person); // true

   

        constructor 本来是用于标识对象类型的。不过，一般认为 instanceof 操作符是确定对象类型更可靠的方式。

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

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

console.log(person2 instanceof Object); // true

console.log(person2 instanceof Person); // true

定义自定义构造函数可以确保实例被标识为特定类型，相比于工厂模式，这是一个很大的好处。

在实例化时，如果不想传参数，那么构造函数后面的括号可加可不加。只要有 new 操作符，就可以调用相应的构造函数

构造函数的主要问题在于，其定义的方法会在每个实例上都创建一遍。

function Person(name, age, job){

this.name = name;

this.age = age;

this.job = job;

this.sayName = new Function("console.log(this.name)"); // 逻辑等价

}

v>

this 对象可以把函数与对象的绑定推迟到运行时；

可以把函数定义转移到构造函数外部：

function Person(name, age, job){

this.name = name;

this.age = age;

this.job = job;

this.sayName = sayName;

}

function sayName() {

      console.log(this.name);

}

这样虽然解决了相同逻辑的函数重复定义的问题，但全局作用域也因此被搞乱了，因为那个函数实际上只能在一个对象上调用。如果这个对象需要多个方法，那么就要在全局作用域中定义多个函数。这会致自定义类型引用的代码不能很好地聚集一起。这个新问题可以通过原型模式来解决。

 

原型模式：

 

 

每个函数都会创建一个 prototype 属性，这个属性是一个对象，包含应该由特定引用类型的实例共享的属性和方法。实际上，这个对象就是通过调用构造函数创建的对象的原型。使用原型对象的好处是，在它上面定义的属性和方法可以被对象实例共享。

function Person() {}     //使用函数表达式也可以:let Person = function() {};

Person.prototype.name = "Nicholas";

Person.prototype.age = 29;

Person.prototype.job = "Software Engineer";

Person.prototype.sayName = function() {

    console.log(this.name);

};

let person1 = new Person();

person1.sayName(); // "Nicholas"

let person2 = new Person();

person2.sayName(); // "Nicholas"

console.log(person1.sayName == person2.sayName); // true

 

无论何时，只要创建一个函数，就会按照特定的规则为这个函数创建一个 prototype 属性（指向原型对象）。默认情况下，所有原型对象自动获得一个名为 constructor 的属性，指回与之关联的构造函数。

在自定义构造函数时，原型对象默认只会获得 constructor 属性，其他的所有方法都继承自Object。每次调用构造函数创建一个新实例，这个实例的内部[[Prototype]]指针就会被赋值为构造函数的原型对象。脚本中没有访问这个[[Prototype]]特性的标准方式，但 Firefox、Safari 和 Chrome会在每个对象上暴露__proto__属性，通过这个属性可以访问对象的原型。在其他实现中，这个特性完全被隐藏了。关键在于理解这一点：实例与构造函数原型之间有直接的联系，但实例与构造函数之间没有。

 

正常的原型链都会终止于 Object 的原型对象;Object 原型的原型是 null;

console.log(Person.prototype.__proto__ === Object.prototype); // true

console.log(Person.prototype.__proto__.constructor === Object); // true

console.log(Person.prototype.__proto__.__proto__ === null); // true

构造函数、原型对象和实例是 3 个完全不同的对象;

instanceof 检查实例的原型链中是否包含指定构造函数的原型;

isPrototypeOf()会在传入参数的[[Prototype]]指向调用它的对象时返回 true:

console.log(Person.prototype.isPrototypeOf(person1)); // true

console.log(Person.prototype.isPrototypeOf(person2)); // true

这里通过原型对象调用 isPrototypeOf()方法检查了 person1 和 person2。因为这两个例子内部都有链接指向 Person.prototype，所以结果都返回 true。

Object.getPrototypeOf()，返回参数的内部特性[[Prototype]]的值:

console.log(Object.getPrototypeOf(person1) == Person.prototype); // true

console.log(Object.getPrototypeOf(person1).name); // "Nicholas"

Object 类型还有一个 setPrototypeOf()方法，可以向实例的私有特性[[Prototype]]写入一个新值。这样就可以重写一个对象的原型继承关系：

let biped = {

   numLegs: 2

};

let person = {

   name: 'Matt'

};

Object.setPrototypeOf(person, biped);

console.log(person.name); // Matt

console.log(person.numLegs); // 2

console.log(Object.getPrototypeOf(person) === biped); // true

警告: Object.setPrototypeOf()可能会严重影响代码性能。

为避免使用 Object.setPrototypeOf()可能造成的性能下降，可以通过 Object.create()来创建一个新对象，同时为其指定原型：

let biped = {

   numLegs: 2

};

let person = Object.create(biped);

person.name = 'Matt';

console.log(person.name); // Matt

console.log(person.numLegs); // 2

console.log(Object.getPrototypeOf(person) === biped); // true

虽然可以通过实例读取原型对象上的值，但不可能通过实例重写这些值

只要给对象实例添加一个属性，这个属性就会遮蔽（shadow）原型对象上的同名属性，也就是虽然不会修改它，但会屏蔽对它的访问。即使在实例上把这个属性设置为 null，也不会恢复它和原型的联

系。不过，使用 delete 操作符可以完全删除实例上的这个属性，从而让标识符解析过程能够继续搜索原型对象。

hasOwnProperty()方法用于确定某个属性是在实例上还是在原型对象上。这个方法是继承自 Object的，会在属性存在于调用它的对象实例上时返回 true;

注意: ECMAScript 的 Object.getOwnPropertyDescriptor()方法只对实例属性有效。要取得原型属性的描述符，就必须直接在原型对象上调用 Object.getOwnPropertyDescriptor()。

有两种方式使用 in 操作符：单独使用和在 for-in 循环中使用。在单独使用时，in 操作符会在可以通过对象访问指定属性时返回 true，无论该属性是在实例上还是在原型上;

console.log("name" in person1); // true

如果要确定某个属性是否存在于原型上，则可以像下面这样同时使用 hasOwnProperty()和 in 操作符：

function hasPrototypeProperty(object, name){

   return !object.hasOwnProperty(name) && (name in object);

}

v>

在 for-in 循环中使用 in 操作符时，可以通过对象访问且可以被枚举的属性都会返回，包括实例属性和原型属性。

要获得对象上所有可枚举的实例属性(不包含其原型上的属性)，可以使用 Object.keys()方法。这个方法接收一个对象作为参数，返回包含该对象所有可枚举属性名称的字符串数组；

这里，keys 变量保存的数组中包含"name"、"age"、"job"和"sayName"。这是正常情况下通过for-in 返回的顺序。而在 Person 的实例上调用时，Object.keys()返回的数组中只包含"name"和

"age"两个属性。如果想列出所有实例属性，无论是否可以枚举，都可以使用 Object.getOwnPropertyNames()：

let keys = Object.getOwnPropertyNames(Person.prototype);

console.log(keys); // "[constructor,name,age,job,sayName]"

Object.getOwnPropertySymbols()：只是针对符号；

let k1 = Symbol('k1'),

k2 = Symbol('k2');

v>

let o = {

[k1]: 'k1',

[k2]: 'k2'

};

console.log(Object.getOwnPropertySymbols(o));

// [Symbol(k1), Symbol(k2)]

v>

 属性枚举顺序

        for-in 循环、Object.keys()、Object.getOwnPropertyNames()、Object.getOwnPropertySymbols()以及 Object.assign()在属性枚举顺序方面有很大区别。for-in 循环和 Object.keys()的枚举顺序是不确定的，取决于 JavaScript 引擎，可能因浏览器而异。

       Object.getOwnPropertyNames()、Object.getOwnPropertySymbols()和 Object.assign()的枚举顺序是确定性的。先以升序枚举数值键，然后以插入顺序枚举字符串和符号键。在对象字面量中定义的键以它们逗号分隔的顺序插入。

Object.values()和 Object.entries()接收一个对象，返回它们内容的数组。Object.values()返回对象值的数组，Object.entries()返回键/值对的数组。

console.log(Object.entries((o)));

// [["foo", "bar"], ["baz", 1], ["qux", {}]]

符号属性会被忽略：

const sym = Symbol();

const o = {

   [sym]: 'foo'

};

console.log(Object.values(o));

// []

console.log(Object.entries((o)));

// []

其他原型语法

function Person() {}

Person.prototype = {

        constructor: Person,//如果 constructor 的值很重要，则可以这样在重写原型对象时专门设置一下它的值

name: "Nicholas",

age: 29,

job: "Software Engineer",

sayName() {

       console.log(this.name);

        }

};

在这个例子中，Person.prototype 被设置为等于一个通过对象字面量创建的新对象。最终结果是一样的，只有一个问题：这样重写之后，Person.prototype 的 constructor 属性就不指向 Person

了。在创建函数时，也会创建它的 prototype 对象，同时会自动给这个原型的 constructor 属性赋

值。而上面的写法完全重写了默认的 prototype 对象，因此其 constructor属性也指向了完全不同的新对象（Object 构造函数），不再指向原来的构造函数。虽然 instanceof操作符还能可靠地返回

值，但我们不能再依靠 constructor 属性来识别类型了，如下面的例子所示：

let friend = new Person();

console.log(friend instanceof Object); // true

console.log(friend instanceof Person); // true

console.log(friend.constructor == Person); // false

console.log(friend.constructor == Object); // true

// 恢复 constructor 属性

Object.defineProperty(Person.prototype, "constructor", {

enumerable: false,

value: Person

});

虽然随时能给原型添加属性和方法，并能够立即反映在所有对象实例上，但这跟重写整个原型是两回事。实例的[[Prototype]]指针是在调用构造函数时自动赋值的，这个指针即使把原型修改为不同

的对象也不会变。重写整个原型会切断最初原型与构造函数的联系，但实例引用的仍然是最初的原型。记住，实例只有指向原型的指针，没有指向构造函数的指针。来看下面的例子：

function Person() {}

let friend = new Person();

Person.prototype = {

constructor: Person,

name: "Nicholas",

age: 29,

job: "Software Engineer",

sayName() {

   console.log(this.name);

}

};

friend.sayName(); // 错误,因为重写整个原型会切断最初原型与构造函数的联系，但实例引用的仍然是最初的原型

 

重写构造函数上的原型之后再创建的实例才会引用新的原型。而在此之前创建的实例仍然会引用最初的原型。

 

通过原生对象的原型可以取得所有默认方法的引用，也可以给原生类型的实例定义新的方法。可以像修改自定义对象原型一样修改原生对象原型，因此随时可以添加方法。比如，下面的代码就给 String

原始值包装类型的实例添加了一个 startsWith()方法：

String.prototype.startsWith = function (text) {

     return this.indexOf(text) === 0;

};

let msg = "Hello world!";

console.log(msg.startsWith("Hello")); // true

因为这个方法是被定义在 String.prototype 上，所以当前环境下所有的字符串都可以使用这个方法。msg是个字符串，在读取它的属性时，后台会自动创建 String 的包装实例，从而找到并调用 startsWith()方法。

原型的问题

原型模式也不是没有问题。首先，它弱化了向构造函数传递初始化参数的能力(构造函数为空函数，属性和方法都添加在了原型对象上)，会导致所有实例默认都取得相同的属性值。虽然这会带来不便，但还不是原型的最大问题。原型的最主要问题源自它的共享特性。我们知道，原型上的所有属性是在实例间共享的，这对函数来说比较合适。另外包含原始值的属性也还好，如前面例子中所示，可以通过在实例上添加同名属性来简单地遮蔽原型上的属性。真正的问题来自包含引用值的属性。来看下面的例子：

function Person() {}

Person.prototype = {

constructor: Person,

name: "Nicholas",

age: 29,

job: "Software Engineer",

friends: ["Shelby", "Court"],

sayName() {

console.log(this.name);

}

};

let person1 = new Person();

let person2 = new Person();

person1.friends.push("Van");

console.log(person1.friends); // "Shelby,Court,Van"

console.log(person2.friends); // "Shelby,Court,Van"

console.log(person1.friends === person2.friends); // true

这里，Person.prototype 有一个名为 friends 的属性，它包含一个字符串数组。然后这里创建了两个 Person 的实例。person1.friends 通过 push方法向数组中添加了一个字符串。由于这个friends 属性存在于 Person.prototype 而非 person1上，新加的这个字符串也会在（指向同一个数组的）person2.friends 上反映出来。如果这是有意在多个实例间共享数组，那没什么问题。但一般来说，不同的实例应该有属于自己的属性副本。这就是实际开发中通常不单独使用原型模式的原因。