javascript创建对象的几种模式

原始模式：

定义：

var obj=new Object();
obj.word01='Hello';
obj.word02='world!';
obj.say=function(){
	alert(this.word01+' '+this.word02);
}

调用：

obj.say();

原始模式的不足：可能需要创建多个实例。

解决方法：工厂模式。

工厂模式

定义一：

function factory(arg01){
var obj=new Object();
  obj.word01='Hello';
  obj.word02='world!';
  obj.arg=arg01;
  obj.say=function(){
      alert(this.word01+' '+this.word02+' '+this.arg);
  }
return obj;
}

定义一的不足：每次调用函数factory()，都要创建新函数say()，意味着每个对象都有自己的 say() 版本。而事实上，每个对象都共享同一个函数。解决办法：在工厂函数外面定义对象的方法：

function factory(arg01){
var obj=new Object();
  obj.word01='Hello';
  obj.word02='world!';
  obj.arg=arg01;
  obj.say=say;
return obj;
}
function say(){//无法给这个函数传递参数
      alert(this.word01+' '+this.word02+' '+this.arg);
  }

调用：

var instance=factory('工厂模式，我是传递进来的参数');
instance.say();

结果：

工厂模式的不足：从功能上讲，这样解决了重复创建函数对象的问题；但是从语义上讲，该函数不太像是对象的方法。

解决方法：构造函数模式。

构造函数模式

定义：

function construct(arg01){
  this.word01='Hello';
  this.word02='world!';
  this.arg=arg01;
  this.say=function(){
      alert(this.word01+' '+this.word02+' '+this.arg);
  }
}

调用：

var obj01=new construct("构造函数模式，我是传递进来的参数");
obj01.say();

构造函数模式产生的问题与工厂模式一样，也会产生对象方法的一个副本，你也可以向工厂模式那样在外部定义对象的方法。但这样又同样会产生语义上面的问题。

解决方法：原型模式

原型模式

定义

function obj(){};
obj.prototype.word01='Hello';
obj.prototype.word02='world!';

obj.prototype.drivers=new Array("Mike","John")
obj.prototype.say=function(){
      alert(this.word01+' '+this.word02+' '+this.drivers);
    }

调用：

var inst=new obj();

inst.drivers.push("我是实例化后新增的参数值");
inst.say();

存在的问题：构造函数无法传递参数，另外，如果对象的属性指向了另一个对象（像这里指向了一个数组），那么这个属性指向的另对象会被对象的多个实例所共享。

由于创建对象时有这么多问题，你一定会想，是否有种合理的创建对象的方法呢？答案是有，需要联合使用构造函数和原型方式。

                                                                                       混合的构造函数和原型模式

定义：

function() obj(){
  this.word01='Hello';
  this.word02='world!';
  this.drivers=new Array("Mike","John");
}
obj.prototype.say=function(){
alert(this.word01+' '+this.word02+' '+this.drivers);
}
var obj01=new obj();

var obj02=new obj();
obj01.drivers.push('实例化后传参');
obj01.say();
obj02.say();

这种方式唯一的缺点就是觉得不够完美；

解决办法：动态原型模式

                                                                                                         动态原型模式

定义：

function obj(){
  this.word01='Hello';
  this.word02='world!';
  this.drivers=new Array("Mike","John");
  if(typeof obj._init=='undefined'){ 
obj.prototype.say=function(){ 
   alert(this.word01+' '+this.word02+' '+this.drivers); 
    return this;
    } 
 obj._init=true; 
  }
}

return this;

的作用就是实现链式操作。
以上方法中最常用的就是混合的构造函数原型模式和动态原型模式。

 

var obj={
fn01:function() {
  this.word01='Hello';
  this.word02='world!';
  this.drivers=new Array("Mike","John");
  if(typeof obj._init=='undefined'){
    obj.prototype.say=function(){
    alert(this.word01+' '+this.word02+' '+this.drivers);
    return this;
    }
    obj._init=true
}


}

继承：通过原型累实现：

将一个对象A的实例赋给另一个对象B的prototype属性

那么对象B就拥有了对象A的所有实例属性和实例方法。当让也可以重写。