/**
* 顺便重温一下对象的创建方式
* 代码简单说明问题就好
* 概念性的东西这里就不提了，只加上自己简单理解
*/
/**
* 工厂模式，就是将手动的创建细节封装在一个方法里，
* return出来一个实例。
* 所谓工厂就是封装创建工程，得到实例。
* 缺点：不能判断对象类型，因为得到的类型都是Object,
* 不能知道是否createPerson的实例
* 是否某对象的实例的判断其实就是实例的原型是否指向对象
* */
function createPerson(name){
var p = new Object();
p.name = name;
p.say = function(){
alert(this.name);
};
return p;
}
var p1 = createPerson('p1');
/**
* 构造函数模式：与工厂的不同是不用显式的去new一个对象
* 因为不管什么函数，只要使用new来调用都起到构造函数的作用。
* 实例可以通过 instanceof Person 来获得对象类型.
* 缺点：每个方法都要在实例上创建一遍
* */
function Person(name){
this.name = name;
this.say = function(){
alert(this.name);
}
}
var p2 = new Person('p2');
console.log(p2 instanceof Person);//true
/**
* 原型模式
* 简单粗暴原型链。
* 对应上述的，原型的方法，各个实例共享相应的属性或方法
* 缺点就是属性修改既影响其他
* */
function Cat(){
}
Cat.prototype.name = 'catName';
Cat.prototype.age = 'catAge';
Cat.prototype.say = function(){
alert(this.name);
};
var c1 = new Cat();
console.log(c1 instanceof Cat);//true
/**
* 组合构造函数和原型模式
* 为了解决上面的问题混合使用两种方式
* 该私有的私有，该共享的共享
* */
function Cat1(name){
this.name = name;
}
Cat1.prototype.say = function(){
alert(this.name);
};
var c2 = new Cat1('c2');
console.log(c2 instanceof Cat1);//true
/**
* 动态原型模式
* 判断属性是否存在，来决定式否增加原型属性
* 和混合模式类似
* */
function Cat2(name){
this.name = name;
if(typeof this.say != 'function'){
Cat2.prototype.say = function(){
alert(this.name);
}
}
}
var c3 = new Cat2('c2');
console.log(c3 instanceof Cat2);//true
/**
* 寄生虫构造函数模式：
* 函数封装创建对象的代码，返回创建的对象。
* 这里于工厂模式的区别在于要通过new 来实例化。本质上是一样的。
* 不可以判断对象类型：
* */
function Dog(name){
var d = new Object();
d.name = name;
d.say = function(){
alert(this.name);
};
return d;
}
var d = new Dog('d');
console.log(d instanceof Dog);//false
/**
* 稳妥构造函数模式：安全
* 没有公共属性，方法不引用this。不使用new来实例化对象
* */
function Dog1(name){
var d = new Object();
d.say = function(){
alert(name);
};
return d;
}
var d2 = Dog1('a');
console.log(d2 instanceof Dog1);//false
js创建对象的几种方式的相关教程结束。
