javascript对象的几种创建方式分析

1.基于字面量JSON方式创建对象
　　1.1 创建对象并初始化
　　//缺点：无法通过构造函数来传值，没有类的约束，无法实现对象的重复利用

var Person = {
　　name:"jack",
　　age:19,
4　　 say:function(){
　　alert(this.name + "," + this.age);
6　　 }
};
Person.say();

 

　　1.2 创建对象后动态初始化对象

var Person = {};
Person.name = "jack";
Person.age = 19;
Person.say = function(){
alert(this.name + "," + this.age);
};
Person.say();

 

2.基于new的方式
//缺点：没有类的约束，无法实现对象的重复利用

var Person = new Object();
Person.name = "jack";
Person.age = 19;
Person.say = function(){
alert(this.name + "," + this.age);
};
Person.say();

 

3.基于工厂的方式
//通过工厂函数进行传值，在函数内创建对象，这样根据不同的参数，创建不同的对象，实现类的模式。
//缺点：可以解决重复利用的问题，但是无法获取对象的类型，如p1和p2都是Object类型通过typeof p1和p2 只能返回object

function createPerson(name,age){
var p = new Object();
p.name = name;
p.age = age;
p.say = function(){
alert(this.name + "," + this.age);
};
return p;
}
var p1 = createPerson("jack",19);
p1.say();
var p2 = createPerson("lucy",29);
p2.say();

 

4.基于构造方法的方式
　　4.1 在构造方法内部直接定义成员
　　//与工厂方式区别是函数名称就是类的名称，函数内部通过this来完成属性的定义
　　//缺点:函数say在内部定义，每次new一个对象都会拷贝一份，占用空间。

function Person(name,age){
this.name = name;
this.age = age;
this.say = function(){
alert(this.name + "," + this.age);
};
}
var p1 = new Person("jack",19);
p1.say();
var p2 = new Person("lucy",20);
p2.say();

 

　　4.2 在外部定义say方法，内部只做方法的引用
　　//可以解决函数每次new就被拷贝的问题
　　//缺点：方法定义成全局，会被window对象所调用，破坏了对象的封装性，如果类中有大量方法，那么就有大量全局函数，不利于开发

function Person(name,age){
this.name = name;
this.age = age;
this.say = say;
}
function say(){
alert(this.name + "," + this.age);
};
var p1 = new Person("jack",19);
p1.say();
var p2 = new Person("lucy",20);
p2.say();

 

5.基于原型的创建方式
　　5.1 在方法内部定义原型
　　//方法new后只有一份在原型中
　　//缺点：1）如果属性多编写麻烦

function Person(name,age){
Person.prototype.name = name;
Person.prototype.age = age;
Person.prototype.say = function(){
alert(this.name+","+this.age);
};
};
var p1 = new Person("jack",19);
p1.say();
var p2 = new Person("lucy",20);
p2.say();

 

　　5.2 在外部动态定义原型
　　//缺点：属性多编写麻烦

function Person(){};
Person.prototype.name = "jack";
Person.prototype.age = 19;
Person.prototype.say = function(){
alert(this.name+","+this.age);
};
var p1 = new Person();
p1.say();
var p2 = new Person();
p2.name = "lucy";//在p2空间中创建name
p2.say();

 

　　5.3 重写原型的方式
　　//缺点：1）无法用构造函数设置值 2）会重写原型 3）当原型属性中有引用类型，会造成变量名重名

function Person(){

};
Person.prototype = {
constructor:Person,//将constructor指向Person
name:"jack",
age:19,
friends:["lili","lala"],
say:function(){
alert(this.name+","+this.age + ",friends: " + this.friends);
}
};
var p1 = new Person();
p1.friends.push("jammy");//这个时候原型中的friends数组被改变，会影响其它对象
p1.say();
var p2 = new Person();
p2.name = "lucy";
p2.say();

 

　　5.4 组合方式（构造方法和原型）,常用的最佳方式
　　//属性通过构造方法，函数通过原型创建

function Person(name,age){
this.name = name;
this.age = age;
}
Person.prototype = {
constructor:Person,
say:function(){
alert(this.name+","+this.age);
}
};
var p1 = new Person("jack",19);
p1.say();
var p2 = new Person("lucy",20);
p2.say();

 

6. 类java方式

function Person(name,age){
this.name = name;
this.age = age;
if(!Person.prototype.say){
Person.prototype.say = function(){
alert(this.name+","+this.age);
}
}

}
var p1 = new Person("jack",19);
p1.say();
var p2 = new Person("lucy",29);
p2.say();

 

 

转载请注明地址：http://www.cnblogs.com/goodpan/p/4676174.html