js创建对象

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

 

1、工厂方式：

function createCar(colors,doors){
	var tempCar = new object();
	tempCar.colors = colors;
	tempCar.doors = doors;
	tempCar.showColor = function showColor(){
		alert(this.color);
	};
}

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

 

2、构造函数的方式:

function Car(colors,doors){
	this.colors = colors;
	this.doors = doors;
	this.showColor = function showColor(){
		alert(this.color);
}

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

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

function Car(){

}
Car.prototype.colors = "red";
Car.prototype.doors = 4;
Car.prototype.showColor = function(){
	alert(this.colors);
};

 //以上面的定义原形创建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、联合使用构造函数和原形方式：

function Car(colors,doors){
	this.colors = colors;
	this.doors = doors;
}
Car.prototype.showColor = function showColor(){
	alert(this.color);
};
var car1 = new Car("red",4);
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

 

function Hotel () {
		this.hotelName = "";
		this.hotelId = "";
		this.star = "";
		this.city = "";
		this.zone = "";
		this.rooms = [];		
	}

	// get and set zone
	Hotel.prototype.setZone = function (zone) {
		this.zone = zone;	
	};
	
	Hotel.prototype.getZone = function () {
		return this.zone;	
	};

        Hotel.prototype.setRooms = function (room) {
		this.rooms[this.rooms.length] = room;
	};
	
	Hotel.prototype.getRooms = function (idx) {
		return (idx >= 0 && idx < this.rooms.length) ? this.rooms[idx] : "";
	};

 

 

 

1、

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

 

2、

var fileObjArr = [];
var length = _tr.length;
_tr.not(":first").each(function(i){
    var qFile = new EipQuestionFile();
    qFile.setFileCode(filecode);
    qFile.setRemark(remark);
    fileObjArr[fileObjArr.length] = qFile;
});
$("#uploadFileList").val(JSON.stringify(fileObjArr));
    //否则无法讲其作为Str传输过去

function EipQuestionFile(){
    this.fileCode = '';
    this.remark = '';           
}
EipQuestionFile.prototype.setFileCode = function (fileCode) {
    this.fileCode = fileCode;   
};
EipQuestionFile.prototype.setRemark    = function(remark){
    this.remark = remark;
}

 ..

 

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。

 

=====================================================================

Form获取值：

 

function setData(){
			var data = $("#uploadTestForm").serializeArray();
			var o={};
			$.each(data, function() {
		        if (o[this.name]!=undefined) {
		            o[this.name].push(this.value || '');
		        } else {
		            o[this.name] = [ this.value || '' ];
		        }
		    	
		    });
		    
		    var newArr = [];
		    var nType = o.nType;
			var strName = o.strName;
			var strUrl = o.strUrl;
			var nAuthenticationPlanTestId = o.nAuthenticationPlanTestId;
		    for(var i in nType){
				var obj = {};
				obj.nType = nType[i];
				obj.strName = strName[i];
				obj.strUrl = strUrl[i];
				obj.nAuthenticationPlanTestId = nAuthenticationPlanTestId[0];
				newArr.push(obj);
			}
			return newArr;
		}

 

$.fn.serializeObject2 = function() {
						    var o = {};
						    var a = this.serializeArray();
						    $.each(a, function() {
						    	var index = this.name.lastIndexOf(".");
						    	if(index != -1){
						    		this.name = this.name.substring(index+1,this.name.length);
							        if (o[this.name]!=undefined) {
							            o[this.name].push(this.value || '');
							        } else {
							            o[this.name] = [ this.value || '' ];
							        }
						    	}
						    });
						    return o;
						};
						
					  	function setData2(form){
					  		var datas = $(form).serializeObject2();
					  		console.log(datas);
						  		var planData = re.data;
						  		var dataList = [];
						  		for(var i=0;i<planData.length;i++){
						  			if(planData[i].level!=0){
						  				planData[i]._index = i;
						  				dataList.push(planData[i]);
						  			}
						  		}
						  		var nDataId = datas.nDataId;
						  		for(var j=0;j<dataList.length;j++){
						  			for(var n=0;n<nDataId.length;n++){
						  				if(dataList[j].id==nDataId[n]){
						  					planData[dataList[j]._index].strntent = datas.strContent[n];
								  			planData[dataList[j]._index].dtPDate = datas.dtPreDate[n];
								  			planData[dataList[j]._index].nAssierId = datas.nAssignUserId[n];
								  			planData[dataList[j]._index].strAserName = datas.strAssignUserName[n];
								  			planData[dataList[j]._index].strRarks = datas.strRemarks[n];
						  				}
						  			}
						  		}
						  		re.data = planData;
					  	}

 

。。。