JavaScript对象定义

[size=large][b]工厂方式[/b][/size]

优点：直观，适合只创建一次的对象缺点：定义的属性和方法只能在该对象中使用

var obj = {};
obj.name = "myname";
obj.password = "mypassword";
obj.login = function(){

};

[size=large][b]构造函数方式[/b][/size]

优点：动态的传递参数缺点：每创建一个对象就会创建相同的方法函数对象，占用大量内存

function User1(name, password) {
	this.name = name;
	this.password = password;
	this.login = function(name,password){
		if(this.name == name && this.password == password) {
			return true;
		}else {
			return false;
		}
	};
}

[size=large][b]原型方式[/b][/size]

优点：每次创建对象时都是使用相同prototype中的方法，不会占用重复的内存缺点：无法动态传递构造参数

function User2() {
}

User2.prototype.name = "prototype name";
User2.prototype.password = "prototype password";
User2.prototype.login = function(name,password){
	if(this.name == name && this.password == password) {
		return true;
	} else {
		return false;
	}
};

[size=large][b]构造及原型混合方式[/b][/size]

优点：综合了construct及prototype方式的优点，可以动态传递构造参数，并且方法函数对象也只创建一个缺点：函数写在对象外面，不太符合面向对象的思想

function User3(name,password) {
	this.name = name;
	this.password = password;
}

User3.prototype.login = function(name,password) {
	if(this.name == name && this.password == password) {
		return true;
	} else {
		return false;
	}
};

[size=large][b]动态原型方式[/b][/size]

优点：将原型函数写在对象定义里面缺点：不支持继承

function User4(name,password) {
	this.name = name;
	this.password = password;
	if(typeof User4.__initialized == "undefined") {
		User4.prototype.login = function(name,password){
			if(this.name == name && this.password == password) {
				return true;
			} else {
				return false;
			}
		};
		User4.__initialized = true;
	}
}

[size=large][b]混合工厂方式[/b][/size]

应用场景很少，用起来像真正的构造函数

function login_util(){
    var obj = {};
    obj.name = "myname";
    obj.password = "mypassword";
    obj.login = function(){

    };
    return obj;
}