1. 工厂模式
function createPerson(name,age,job){
let obj = new Object();
obj.name = name;
obj.age = age;
obj.job = job;
obj.say = function(){
console.log(this.name);
};
return obj;
}
let person = createPerson('tom',21,'student');
person.say();// tom
- 特点：简单的封装了创建对象的过程，在函数内部显示创建对象。解决了重复创建对象的问题。
- 缺点：对象的类型不清楚
console.log(person.constructor);// [Function: Object] 不知道这是什么类型
console.log(person instanceof Object);// true
2. 构造函数模式
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.say = function(){
console.log(this.name)
};
}
let person1 = new Person('tom',21,'student');
let person2 = new Person('jack',20,'teacher');
person1.say();// tom
person2.say();// jack
- 特点：函数内部没有显示创建对象，直接把属性赋给this，没有return，
用于创建对象时需要使用new操作符。（构造函数名一般大写开头） - 相对于工厂模式的改进：现在明确的知道了这个对象类型是Person
console.log(person1.constructor);// [Function: Person]
console.log(person1.constructor == Person);// true
console.log(person1 instanceof Person);// true
console.log(person1 instanceof Object);// true
console.log(person2.constructor);// [Function: Person]
console.log(person2.constructor == Person);// true
console.log(person2 instanceof Person);// true
console.log(person2 instanceof Object);// true
- 缺点：创建实例时，同样的方法(属性)被重复创建（意思是方法其实可以共享，没必要浪费空间）
console.log(person1.say == person2.say);// false
//每个实例上的方法是不同的，但是这样没有必要
3. 原型模式
- 为了改进构造模式重复创建属性/方法的缺点，利用原型的方法创建对象，实现了方法和属性的共享。
function Person(){
};
Person.prototype.name = 'tom';
Person.prototype.age = 21;
Person.prototype.say = function(){
console.log(this.name);
}
let person1 = new Person();
let person2 = new Person();
console.log(person1.name);// tom 这个name属性是从原型上找到的
console.log(person2.name);// tom 这个name属性是从原型上找到的
// 上面这两个实例访问的都是原型上共享的属性
console.log(person1.name == person2.name);// true
console.log(person1.say == person2.say);// true
// 实例上还没有定义name属性
console.log(person1.hasOwnProperty('name'));// false
console.log(person2.hasOwnProperty('name'));// false
- 在实例上重新定义name属性将会屏蔽掉原型上的name属性
person1.name = 'elric';
//实例上定义了同名的name属性，访问时对象上的name优先于与原型上的name
//（也就是说当对象上找不到name才会到原型上找）
console.log(person1.name);// elric 对象上的name
console.log(person2.name);// tom 原型上的name
- 为了省去大量重复的Person.prototype，可以直接重写Person.prototype
// 对象字面量形式
Person.prototype = {
constructor:Person,// 显示修正constructor的指向
name:'tom',
age:21,
say(){
console.log(this.name);
}
}
// Object.defineProperties()方式
Object.defineProperties(Person.prototype,{
'constructor':{
enumerable: false,
value:Person
},
'name':{
value:'tom'
},
'age':{
value:21
},
'say':{
value:function(){
console.log(this.name);
}
}
})
- 原型模式缺点：属性共享有时候会带来麻烦，特别是在共享引用型属性时，尽管可以在对象上定义同名属性来屏蔽原型属性。（因为引用类型的特点，当一个实例上修改了该共享属性，那么所有实例上的该属性都会被改变，如果要实现私有的属性的话就有问题了）
function Person(){
};
Person.prototype = {
constructor:Person,
name:'tom',
age:21,
friends:['jack','merry'],
say(){
console.log(this.name);
}
}
let person1 = new Person();
let person2 = new Person();
person1.friends.pop();// 修改了原型上的引用类型属性
console.log(person1.friends);// ['jack']
console.log(person2.friends);// ['jack']
4. 组合使用构造函数模式和原型模式
创建自定义类型的最常见方式，就是组合使用构造函数模式与原型模式。构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度地节省了内存。另外，这种混成模式还支持向构造函数传递参数；可谓是集两种模式之长。
- 实例私有属性使用构造模式声明，共享属性使用原型模式声明，利用了两个模式的优点。
function Person(name,age){
this.name = name;
this.age = age;
this.friends = ['jack','ben'];
}
Person.prototype = {
constructor:Person,
say(){
console.log(this.friends);
}
}
let person1 = new Person('tom',21);
let person2 = new Person('merry',10);
person1.friends.push('tony');
person1.say();// [ 'jack', 'ben', 'tony' ]
person2.say();// [ 'jack', 'ben' ]
console.log(person1.name == person2.name);// false 属性不共享
console.log(person1.say == person2.say);// true 方法共享
5. 动态原型模式
- 把原型模式封装到构造函数中去
function Person(name,age){
// 属性，仍然使用构造模式的方法
this.name = name;
this.age = age;
// 方法，使用原型，同时初始化方法时要注意时判断是否已存在
if(typeof this.say != 'function'){
Person.prototype.say = function(){
console.log(this.name);
}
}
}
let person1 = new Person('tom',21);
let person2 = new Person('jack',19);
person1.say();// tom
person2.say();// jack
console.log(person1.name == person2.name);// false
console.log(person1.say == person2.say);// true