JavaScript创建对象的几种方式:
1.通过工厂方式
缺点:无法判断创建对象的类型,通过typeof只会返回Object;
2.通过构造函数方式
缺点:每一个所创建的对象中都会存在一个方法的拷贝,如果对象的方法很多的话,空间的占用率就会大大的增加。
解决方法如下:将方法抽出来,设置成全局函数;但是这也带来一个问题,如果设置为全局函数,这个函数就会被window调用,此时就会破坏对象的封装性。
3.通过原型方式:通过原型的方式可以有效的完成对象的封装。
(重点理解)原型是js中非常特殊的一个对象,当一个函数创建之后,会随之就产生一个原型对象,原型中属性值是不会被替换。
原型的内存模型是重点,这个上网可以好好找找,理解很重要。
原型的检查。
原型的重写:json格式。
缺点:无法通过构造函数来设置属性值,只能在对象生成后再去改变属性值。如果一个对象进行属性push,会造成另一个对象造成影响。
4.通过原型+构造函数方式来创建对象:对象之间的属性互不干扰,各个对象间共享同一个方法。
将属性在构造函数中定义,将方法在原型中定义。这种方式是目前最常用的创建对象的方式。
这种方式的好处是对象之间的属性互不干扰,各个对象间共享同一个方法。
5.通过动态原型方式创建对象,让所有对象共享一个方法,而每个对象都拥有自己的属性。
1.通过工厂方式
缺点:无法判断创建对象的类型,通过typeof只会返回Object;
<script type="text/javascript">
function createPerson(name,age) {
var obj = new Object();
obj.name = name;
obj.age = age;
obj.say = function() {
alert(this.name+","+this.age);
}
return obj;
}
//无法检测对象p1和p2的数据类型
var p1 = createPerson("aa",22);
var p2 = createPerson("bb",33);
p1.say();
p2.say();
</script>
2.通过构造函数方式
缺点:每一个所创建的对象中都会存在一个方法的拷贝,如果对象的方法很多的话,空间的占用率就会大大的增加。
解决方法如下:将方法抽出来,设置成全局函数;但是这也带来一个问题,如果设置为全局函数,这个函数就会被window调用,此时就会破坏对象的封装性。
<script type="text/javascript">
function Person(name,age){
this.name = name;
this.age = age;
this.say = say;
this.sayHello = function(){
alert(this.name + ":" + this.age);
}
}
function say(){
alert(this.name + ":" + this.age);
}
var p1 = new Person("a",1);
var p2 = new Person("b",2);
alert(p1.sayHello == p2.sayHello);//false
alert(p1.say == p2.say);//true
</script>
3.通过原型方式:通过原型的方式可以有效的完成对象的封装。
(重点理解)原型是js中非常特殊的一个对象,当一个函数创建之后,会随之就产生一个原型对象,原型中属性值是不会被替换。
原型的内存模型是重点,这个上网可以好好找找,理解很重要。
原型的检查。
原型的重写:json格式。
缺点:无法通过构造函数来设置属性值,只能在对象生成后再去改变属性值。如果一个对象进行属性push,会造成另一个对象造成影响。
<script type="text/javascript">
//通过原型方式创建对象
function Person(){
}
Person.prototype.name = "ztchen";
Person.prototype.age = 24;
Person.prototype.getInfo = function(){
alert(this.name + ";" + this.age);
}
var p1 = new Person();
var p2 = new Person();
p1.name = "lishi";
p1.getInfo();//打印lishi:24
p2.getInfo();//打印ztchen:24
</script>
4.通过原型+构造函数方式来创建对象:对象之间的属性互不干扰,各个对象间共享同一个方法。
将属性在构造函数中定义,将方法在原型中定义。这种方式是目前最常用的创建对象的方式。
这种方式的好处是对象之间的属性互不干扰,各个对象间共享同一个方法。
<script type="text/javascript">
//通过原型 + 构造函数方式创建对象
function Person(name,age,friends){
this.name = name;
this.age = age;
this.friends = friends;
}
Person.prototype.getInfo = function(){
alert(this.name + ";[" + this.friends + "]");
}
var p1 = new Person("ztchen",24,["aa","bb"]);
var p2 = new Person("lishi",24,["cc","dd"]);
p1.friends.push("tt");
p2.friends.push("yy");
p1.getInfo();//打印ztchen:[aa,bb,tt]
p2.getInfo();//打印lishi:[cc,dd,yy]
alert(p1.getInfo == p2.getInfo);//打印true
</script>
5.通过动态原型方式创建对象,让所有对象共享一个方法,而每个对象都拥有自己的属性。
<script type="text/javascript">
//通过动态原型方式创建对象
function Person(name,age,friends){
this.name = name;
this.age = age;
this.friends = friends;
//判断Person.prototype.getInfo是否存在,若存在就不会创建
if(!Person.prototype.getInfo){
Person.prototype.getInfo = function(){
alert(this.name + ";[" + this.friends + "]");
}
}
}
var p1 = new Person("ztchen",24,["aa","bb"]);
var p2 = new Person("lishi",24,["cc","dd"]);
p1.friends.push("tt");
p2.friends.push("yy");
p1.getInfo();//打印ztchen:[aa,bb,tt]
p2.getInfo();//打印lishi:[cc,dd,yy]
alert(p1.getInfo == p2.getInfo);
</script>