js创建对象的几种方式

/**
 * 顺便重温一下对象的创建方式
 * 代码简单说明问题就好
 * 概念性的东西这里就不提了，只加上自己简单理解
 */

/**
 * 工厂模式，就是将手动的创建细节封装在一个方法里，
 * 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