JavaScript创建对象的几种方法

最新推荐文章于 2024-09-11 15:33:18 发布

tt_twilight

最新推荐文章于 2024-09-11 15:33:18 发布

阅读量258

点赞数

分类专栏： javascript 文章标签： javascript

javascript 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

参考的几篇文章：

http://www.cnblogs.com/FromSnatch/archive/2012/05/20/2510682.html

http://www.jb51.net/article/46249.htm

http://www.cnblogs.com/wangyingblog/p/5583825.html

http://www.jb51.net/article/50876.htm

感谢！！！

看到JS自创建对象的地方时，对于prototype对象比较困惑，所以记录一下参考几篇文章之后的理解。

1.原始方法

1）字面量方法

var clock={
  hour:12,
  minute:10,
  second:10,
  showTime:function(){
   alert(this.hour+":"+this.minute+":"+this.second);
  }
 }
 clock.showTime();//调用

2）创建Object实例

var clock = new Object();
//动态添加属性和方法
 clock.hour=12;
 clock.minute=10;
 clock.showHour=function(){alert(clock.hour);};
 clock.showHour();//调用

上面的方式通过new关键字生成一个对象，然后根据JS是动态语言的特性添加属性和方法，构

造一个对象。其中的this是表示调用该方法的对象。

这种方式的问题是如果需要多次创建对象，则需要重复代码多次，不利于代码的复用。

2.工厂模式

function createClock(hour,minute,second){
  var clock = new Object();
   clock.hour=hour;
   clock.minute=minute;
   clock.second=second;
   clock.showHour=function(){
   alert(this.hour+":"+this.minute+":"+this.second);
  };
  return clock;
 }
 var newClock = createClock(12,12,12);//实例化
 newClock.showHour();//调用

上面的方式虽然可以提高代码的复用率，但和面向对象中类的概念相比有一个很大的缺陷。面

相对象强调对象的属性私有，而对象的方法是共享的。而上面的工厂方法创建对象的时候要为每个

对象创建各自私有的方法。同时由于为每个对象都创建逻辑相同的方法，浪费内存。

当然可以把方法拿到函数外面：

function createClock(hour,minute,second){
  var clock = new Object();
   clock.hour=hour;
   clock.minute=minute;
   clock.second=second;
  return clock;
 };
 function showHour(){
   alert(this.hour+":"+this.minute+":"+this.second);
 }
 var newClock = createClock(12,12,12);//实例化
 newClock.showHour();//调用

但这么一来的话，对象的函数又和对象成了相互独立，不相干的了。这和面向对象中特定方法属于特定类的思想不符合。

3.构造函数模式

function clock(hour,minute,second){
  this.hour = hour;
  this.minute = minute;
  this.second = second;
  this.showTime = function(){
   alert(this.hour+":"+this.minute+":"+this.second);
  }
 }
 var newClock =new  clock(12,12,12); 
 alert(newClock.hour);

注意:这个new关键字是必须，如果不加，clock就不会当成构造函数调用，而只是一个普通的函数。同时，还会意外地给他的外部作用域即window添加属性，因为此时构造函数内部的this已经映射到了外部作用域了。所以为了安全起见，可以这样创建

function clock(hour,minute,second){
  if(this instanceof clock){
   this.hour = hour;
   this.minute = minute;
   this.second = second;
   this.showTime = function(){
    alert(this.hour+":"+this.minute+":"+this.second);
   }
  }
  else{
   throw new Error("please add 'new' to make a instance");
  }
 }

当调用new Person的时候，在执行第一行代码前，先生成一个Person对象，并将对象在内存中的索引赋值给this关键字，此时可以通过this关键字操作新生成的对象，如下面的添加属性或方法

构造函数的缺点：构造函数模式和工厂模式一样，由于this指针在对象实例的时候发生改变指向新的实例，这时新实例的方法也要重新创建，如果n个实例就要n次重建相同的方法。（即：使用this指针，实例初始化时会为每个实例开辟构造方法所包含的所有属性和方法所需的内存空间）于是让我们来揭开原型模式吧。

4.原型模式

function clock(){
 }
 clock.prototype.hour=12;
 clock.prototype.minute=12;
 clock.prototype.second=12;
 clock.prototype.showTime=function(){
  alert(this.hour+":"+this.minute+":"+this.second);
 }
 var newClock = new clock();
 newClock.showTime();

深度理解原型模型很重要：

首先，每个函数都有一个prototype(原型)属性，这个指针指向的就是clock.prototype对象。而这个原型对象在默认的时候有一个属性constructor，指向clock，这个属性可读可写。而当我们在实例化一个对象的时候，实例newClock除了具有构造函数定义的属性和方法外（注意，只是构造函数中的）,还有一个指向构造函数的原型的指针，ECMAScript管他叫[[prototype]]，这样实例化对象的时候，原型对象的方法并没有在某个具体的实例中，因为原型没有被实例化。（具体用new创建对象时发生的事情可以参考：http://www.cnblogs.com/wangyingblog/p/5583825.html）

注：这里的clock.prototype.constructor是指向clock的，并且我们可以用constructor来判断对象类型（具体见：http://blog.csdn.net/tt_twilight/article/details/76862327）

所以这种模式定义的对象，在调用方法的时候过程：调用newClock.showTime();先看实例中有没有，有调之，无追踪到原型，有调之，无出错，调用失败。

当然可以这样写：

function clock(){
 }
 clock.prototype={
  constructor:clock,    //必须手动设置这个属性，不然就断了与构造函数的联系了。没有实例共享原型的意义了。
  hour:12,
  minute:12,
  second:12,
  showTime:function(){
   alert(this.hour+":"+this.minute+":"+this.second)
  }
 }
 var newClock = new clock();
 newClock.showTime();

该方法的问题首先是构造函数不能传参，每个新生成的对象都有默认值。其次，方法共享没有任何问题，但是属性共享会有问题。

5.构造-原型组合模式

function clock(hour,minute,second){
  this.hour = hour;
  this.minute = minute;
  this.second = second;
 }
 
 clock.prototype.showTime=function(){alert(this.hour+":"+this.minute+":"+this.second);}
 var newClock = new clock(12,12,12);
 newClock.showTime();

这里我们将属性放在构造函数中，更显得对象的具体性。

当然可以将方法拿到构造函数里面：

function clock(hour,minute,second){
  this.hour = hour;
  this.minute = minute;
  this.second = second;

if(typeof clock._initialized=="undefined"){//如果Person对象中的_initialized为undefined，表明还没有为Person的原型添加方法 

 clock.prototype.showTime=function(){alert(this.hour+":"+this.minute+":"+this.second);}

 clock._initialized=true;//设置为true，不必再为prototype添加方法 

}

}
 
 var newClock = new clock(12,12,12);
 newClock.showTime();

这种方法和构造函数/原型方式大同小异。只是将方法的添加放到了构造函数之中，同时在构造

函数Person上添加了一个属性用来保证if语句只能成功执行一次。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

因为JS是动态的，所以可以动态往对象里添加属性和方法，下面解释一下使用prototype和不使用prototype的区别

举例：

function ListCommon2(first,second,third) 
{ 
this.First=function () 
{ 
alert("first do"+first); 
} 
} 
ListCommon2.do1=function(first) 
{ 
// this.First(); 
alert("first do"+first); 
} 
ListCommon2.prototype.do2=function(first) 
{ 
// this.First(); 
alert("first do"+first); 
}

结果：

var t1=new ListCommon2("烧水1","泡茶1","喝1"); 
// t1.do1();//调用出错 
ListCommon2.do1("烧水1"); 
var t2=new ListCommon2("烧水2","泡茶2","喝2"); 
t2.do2("烧水2");// 
// ListCommon2.do2("烧水1");//调用出错

经过测试发现，没有使用prototype的方法相当于类的静态方法，因此可以这样调用，ListCommon2.do1("烧水1");，如果这样调用就会出错，t1.do1();
相反，使用prototype的方法相当于类的实例方法，不许new后才能使用，ListCommon2.do2("烧水1");这样就会出错。

结论：

1.对象方法包括构造函数中的方法以及构造函数原型的方法

2.类方法：这里所说的“类”其实是一个函数，在JS中函数也是一个对象，所以可以为函数添加属性和方法（这时的属性和方法不属于对象属性和方法）。

3.原型方法用于对象实例共享。