javascript 之 对象

可以通过 Object 构造函数或对象字面量的方式创建对象，但是这些方式的缺点是使用同一个接口创建多个对象，会产生大量重复的代码。

1.工厂模式

function createPerson(name, age, job) {
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function () {
    console.log(this.name);
  }
  return o;
}
​
var person1 = createPerson('Nike', 18, 'Student');
console.log(person1.constructor.name) // Object

优点：解决了创建多个相似对象的问题。

缺点：没有解决对象的识别问题（如何知道一个对象的类型）

2.构造函数模式

function Person(name, age, job) {
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = function () {
    console.log(this.name);
  }
}
​
var person1 = new Person('Nike', 18, 'Student');
console.log(person1.constructor.name) // Person

优点：可以将构造函数的实例标识为一种特定的类型

缺点：每个方法在每个实例上都要重新创建一次（它们做的事情都一样），如果方法写成全局函数就没有封装性可言了。

3.原型模式

function Person () {}
Person.prototype = {
  constructor: Person,
  name: 'Nike',
  friends: ['阿猫', '阿狗']
}
​
var person1 = new Person();
var person2 = new Person();
​
person1.friends.push('阿黄');
console.log(person1.friends); // ['阿猫', '阿狗', '阿黄']
console.log(person2.friends); // ['阿猫', '阿狗', '阿黄']

缺点

• 不能用构造函数传递初始化参数，使得所有实例默认情况下取得相同的属性值。

• 原型中的属性在很多实例中共享，当属性是基本值的时候可以实例上添加一个同名属性隐藏原型中对应的属性，但当属性是引用类型的时候，修改一个实例的属性时是在原型上直接修改的，其它实例的属性也会更着改变。

4.组合使用构造函数和原型模式

function Person(name, age, job) {
  this.name = name;
  this.age = age;
  this.job = job;
  this.friends: ['阿猫', '阿狗']
}
Person.prototype = {
  constructor: Person,
  sayName : function () {
    console.log(this.name);
  }
}
​
var person1 = new Person('Nike', 18, 'Student');
var person2 = new Person('Bob', 22, 'Doctor');
​
person1.friends.push('阿黄');
console.log(person1.friends); // ['阿猫', '阿狗', '阿黄']
console.log(person2.friends); // ['阿猫', '阿狗']

思想：用构造函数模式定义实例属性，原型模式定义方法和共享的属性

优点

• 每个实例都有自己的一份属性的副本，同时共享着方法的引用，节约内存

• 支持构造函数传参

5.动态原型模式

function Person(name, age, job) {
  this.name = name;
  this.age = age;
  this.job = job;
  if (typeof this.sayName != 'function') { // 检查初始化之后应该存在的任何属性和方法
    Person.prototype.sayName = function () {
      console.log(this.name)
    }
  }
}
​
var friend = new Person('Nike', 18, 'Student');
friend.sayName();

优点：通过检测某个应该存在的方法在构造函数中初始化原型（必要情况下），即同时使用构造函数和原型

注意：使用动态原型模式是不能使用对象字面量重写原型，因为在已经创建了实例的情况下重写原型会切断现有实例和原型之间的联系。

6.寄生构造函数模式

function Person(name, age, job) {
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function () {
    console.log(this.name);
  }
  return o;
}
​
var friend  = new Person('Nike', 18, 'Student');
friend.sayName(); // Student
​
// ======================================================== //
​
function Sp () {
    var values = new Array();
    values.push.apply(values, arguments);
    values.toPip = function () {
        return this.join("|")
    }
    return values;
}
​
var colors = new Sp('red','blue','pink');
console.log(colors.toPip()) // red|blue|pink

优点：可以在一些特殊情况下为对象创建构造函数

注意：

• 构造函数没有return的时候，默认会返回新对象实例，有return的时候，可以重写调用构造函数时返回的值。

• 返回的对象和构造函数或构造函数的原型属性间没有关系。不能用instanceof 确定对象类型

7.稳妥构造函数模式

function Person(name, age, job) {
  var o = new Object();
  o.sayName = function () {
    console.log(name);
  }
  return o;
}
​
var friend  =  Person('Nike', 18, 'Student');
friend.sayName(); // Nike 该属性只能通过 sayName 方法访问

概念：稳妥对象，是指没有公共属性，而且其方法不引用 this 的对象。

优点：安全的环境中（禁止使用 this 或 new），或防止数据被其他应用程序改动

注意：

• 创建对象的实例方法不引用 this；不使用 new 操作符调用构造函数。

• 返回的对象和构造函数或构造函数的原型属性间没有关系。不能用instanceof 确定对象类型