js创建对象

Java代码  

1. //定义一个apple对象的构造函数    
2. function Apple{    
3.     this.color='red';    
4. }    
5. //创建一个apple对象    
6. var apple1 = new Apple（）；    
7. //我还可以这么创建apple对象    
8. var apple2 = {    
9.  color:'red';    
10. }    
11. 这两个apple对象在内存中都是完全一样的。只不过js提供了两种创建方式而已。   

 

1、工厂方式：

Java代码  

1. function createCar(colors,doors){  
2.     var tempCar = new object();  
3.     tempCar.colors = colors;  
4.     tempCar.doors = doors;  
5.     tempCar.showColor = function showColor(){  
6.         alert(this.color);  
7.     };  
8. }  

 缺点：不像常用的面向对象声明的方式;每声明一个Car实例，就要创建多一个showColor函数，不能复用，浪费内存 。

 

2、构造函数的方式:

Java代码  

1. function Car(colors,doors){  
2.     this.colors = colors;  
3.     this.doors = doors;  
4.     this.showColor = function showColor(){  
5.         alert(this.color);  
6. }  

 优点：以更面向对象的方式
 缺点：每声明一个Car实例，就要创建多一个showColor函数，不能复用，浪费内存。 

3、prototype原形的方式：
//首先定义构造函数

Java代码  

1. function Car(){  
2.   
3. }  
4. Car.prototype.colors = "red";  
5. Car.prototype.doors = 4;  
6. Car.prototype.showColor = function(){  
7.     alert(this.colors);  
8. };  

 //以上面的定义原形创建Car
var car1 = new Car();
var car2 = new Car();

优点：重用代码，car1.showColor，car2.showColor指向的是同一个函数位置。
缺点：构造函数没有参数，不能在调用构造函数时，自定义自己的Car。
注：这个缺点可以这样解决：var car1 = new Car();声明后，再指定它自己的字段和方法：car1.doors = 6;
也可以改变方法指针指向另一个方法：car1.showColor = changeColor;


综合解决以上问题的方法：
4、联合使用构造函数和原形方式：

Java代码  

1. function Car(colors,doors){  
2.     this.colors = colors;  
3.     this.doors = doors;  
4. }  
5. Car.prototype.showColor = function showColor(){  
6.     alert(this.color);  
7. };  
8. var car1 = new Car("red",4);  
9. var car2 = new Car("blue",6);  

 优点：这样一来便很好地解决了上面的问题，在调用构造函数时，自定义自己的Car；也解决了方法复用的问题。

 

prototype就是“一个给类的对象添加方法的方法”，使用prototype属性，可以给类动态地添加方法。 
当你用prototype编写一个类后，如果new一个新的对象，浏览器会自动把prototype中的内容替你附加在对象上。这样，通过利用prototype就可以在JavaScript中实现成员函数的定义，甚至是“继承”的效果。

 

 

http://blog.csdn.net/xiaoyuemian/archive/2009/01/20/3844305.aspx

 

Java代码  

1. function Hotel () {  
2.         this.hotelName = "";  
3.         this.hotelId = "";  
4.         this.star = "";  
5.         this.city = "";  
6.         this.zone = "";  
7.         this.rooms = [];          
8.     }  
9.   
10.     // get and set zone  
11.     Hotel.prototype.setZone = function (zone) {  
12.         this.zone = zone;     
13.     };  
14.       
15.     Hotel.prototype.getZone = function () {  
16.         return this.zone;     
17.     };  
18.   
19.         Hotel.prototype.setRooms = function (room) {  
20.         this.rooms[this.rooms.length] = room;  
21.     };  
22.       
23.     Hotel.prototype.getRooms = function (idx) {  
24.         return (idx >= 0 && idx < this.rooms.length) ? this.rooms[idx] : "";  
25.     };  

 

 

 

1、

Java代码  

1. for(var i=0; i<recordList.length; i++){  
2.         fileCtrl.addFileList.push(recordList[i]);  
3.         fileCtrl.currFileList.push(recordList[i]);  
4.     }  
5.     alert(JSON.stringify(fileCtrl));  

 

2、

Java代码  

1. var fileObjArr = [];  
2. var length = _tr.length;  
3. _tr.not(":first").each(function(i){  
4.     var qFile = new EipQuestionFile();  
5.     qFile.setFileCode(filecode);  
6.     qFile.setRemark(remark);  
7.     fileObjArr[fileObjArr.length] = qFile;  
8. });  
9. $("#uploadFileList").val(JSON.stringify(fileObjArr));  
10.     //否则无法讲其作为Str传输过去  
11.   
12. function EipQuestionFile(){  
13.     this.fileCode = '';  
14.     this.remark = '';             
15. }  
16. EipQuestionFile.prototype.setFileCode = function (fileCode) {  
17.     this.fileCode = fileCode;     
18. };  
19. EipQuestionFile.prototype.setRemark    = function(remark){  
20.     this.remark = remark;  
21. }  

 ..

 

JS中创建对象的几种常用方法：

1. 简单对象字面量

这是最简单的创建对象的方法，也是经常在入门书籍中看到的方法：

//创建一个简单对象字面量var person = {};    // 加入属性和方法person.name = 'ifcode';person.setName = function(theName) {   person.name = theName;}

非常简单，但一般情况下不推荐这种方法。JS good parts书中认为这种写法可读性不够强，作者推荐的是后面一种写法。

2. 嵌套对象字面量

JS good parts中推荐这种写法:

var person = {    name: 'ifcode',    setName: function(theName) {        this.name = theName;    }}

这种写法可读性很强，person对象的所有属性和方法都包含在其身体内，先的一目了然。

以上两种写法适用于只存在一个实例的对象，也就是某种意义上的singlton pattern。

下面介绍的几种方法比较适用于创建多个对象实例。

3. 简单构造函数

构造函数一般都符合factory pattern，根据默认的规则，构造函数应当首字母大写：

Person = function(defaultName) {    this.name = defaultName;    this.setName = function(theName) {        this.name = theName;    }}person = new Person('ifcode');

利用构造函数就可以方便地创建多个对象实例了。

4. 使用原型（prototype）的构造函数

这里简单回顾一下prototype的作用。prototype或许是某种意义上最接近传统OOP中class的东西了。所有创建在prototype上得属性和方法，都将被所有对象实例分享。

Person = function(defaultName) {    this.name = defaultName;}Person.prototype.setName = function(theName) {    this.name = theName;}

---

其实创建对象的方法还有很多，这些过于灵活的方法也是许多人在初接触JS时感到困惑的原因。我个人比较偏向2和4：单一实例用2，多个实例用4。