创建一个Object:
var person = new Object();
person.name="Nicklas";
person.age=29;
person.job="Software Engineer";
person.sayName = function(){
alert(this.name);
};
person.sayname();// alerts "Nicklas"
此处缺点:此对象为一次性创建,无法复用。如需创建同样的对象,则需copy一份完全一样的代码。
工厂模式:
function createPerson(name,age,job){
var o = new Object();
o.name=name;
o.age = age;
o.job = job;
o.sayName = function(){alert(this.name);};
return o;
}
var person1 = createPerson("nicholas",29,"software Engineer");
var person2 = createPerson("greg",27,"doctor");
person1.sayName(); // alerts "nicholas"
person2 .sayName();//alerts"Greg"
此处缺点:不能识别对象类型(只知道是Object)
构造函数模式:
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){alert(this.name);};
}
var person1 = new Person("nicholas",29,"software Engineer");
var person2 = new Person"greg",27,"doctor");
person1.sayName(); // alerts "nicholas"
person2 .sayName();//alerts"Greg"
好处:
解决了对象识别:
alert(person1.consturctor==Person); //true
person1 instanceof Person //true
缺点:
成员函数(此处为 sayName)会在每次new Person时重新分配空间(相当于new Function,此处与java不同),从而会在大量使用此法创建对象时浪费很多空间
另记:构造函数模式的另类调用:
Person("greg",27,"doctor"); //将Person中的字段及方法添加到window对象
window.sayName(); //alerts "Greg"
另类调用2:
var o = new Object();
Person.call(o,"Kristen",25,"Nurse");
o.sayName(); //alerts Kristen
call() (或 apply() 在某个特定对象的作用域中调用Person()函数)
可以针对上述sayName方法进行改造来避免上述缺点:
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = sayName;
}
function sayName(){
alert(this.name);
}
缺点:虽然解决了空间浪费问题,但如果对象方法有很多,则会有太多的全局函数。并且此种方法也没有封装性可言。
原形模式:
function Person(){
}
Person.prototype.name="Nicholas";
Person.prototype.age=29;
Person.prototype.job="software Engineer";
Person.prototype.sayName=function(){alert(this.name);};
var person1 = new Person();
person1.sayName(); //alerts "Nicholas"
此处避免了前面成员函数的相关问题。所有 new Person()出来的对象,均共享一个prototype
可以通过重新赋值来更改对象继承(共享)自原型的值:
person1.name="greg";
也可以通过delete运算符来删除对象的属性(只会删除对象实例的,不会删除prototype的)
delte person1.name;
person1.sayName(); //alerts "Nicholas" 先搜索对象中的name属性,此时name属性被删除,则寻找prototype中的name属性
可以用hasOnwProperty()方法检测属性是来自对象的,还是来自prototype的
alert(person1.hasOnwProperty(“name")); //已经delete掉了。所以为false
alert(person1.hasOnwProperty(“age")); //true
另一种原型模式
function Person(){
}
Person.prototype={
name:"Nicholas",
age:29,
job:"Software Engineer",
sayName : function(){alert(this.name);}
};
与前一种有何不同?consturctor 属性不再指向Person
var person = new Person();
alert(person.constructor == Person);//false
alert(person.consturcotr == Object);//true
那么如何在使用上述原型模式的同时,保证constructor属性为Person呢?显示指定
functon Person(){
}
Person.prototype={
consturcotr:Personm,
name:"Nicholas",
age:29,
job:"Software Engineer",
sayName : function(){alert(this.name);}
};
var person = new Person();
alert(person.constructor == Person);//true
注意原形的动态性
function Person(){
}
var person=new Person();
Person.prototype={
consturcotr:Personm,
name:"Nicholas",
age:29,
job:"Software Engineer",
sayName : function(){alert(this.name);}
};
person.sayName(); //error
为什么??
因为重写prototype前,person对象已被new出。已new出的对象的属性不会随这prototype的更改而变化。(可以理解为新的prototype是重新指向了一个新的对象,老的对象引用还在被已经new出的person对象持有)
js原生对象也可以扩展:
String.prototype.startsWith=function(text){
return this.indexOf(text)==0;
};//判断字符串是不是以某字符开始
var msg="hello world!";
alert(msg.startsWith("hello")); //true
注意:若prototype中有的属性为引用行(如Array),则具体实例在调用该原型引用的方法时,会直接影响原型。例:
function Person(){
}
Person.prototype={
consturcotr:Personm,
name:"Nicholas",
age:29,
job:"Software Engineer",
friends:["Shelby","Court"],
sayName : function(){alert(this.name);}
};
var person1 = new Person();
var person2 = new Person();
person1.friends.push("van");
alert(person1.friends); //"Shelby,Court,Van"
alert(person2.friends); //"Shelby,Court,Van"
最优的创建自定义类型的方法:结合构造函数模式和原型模式
function Person(name,age,job){
this.name=name;
this.age = age;
this.job = job;
this.friends=["Shelby","Court"];
}
Person.prototype={
constructor : Person,
sayName : function(){alert(this.name);}
};
var person1 = new Person("nicholas",29"Software Engineer");
var person2 = new Person("greg",29,"Doctor");
person1.friends.push("Van");
alert(person1.friends); //"Shelby,Court,Van"
alert(person2.friends);//Shelby,Court
alert(person1.friends===person2.friends); //false
alert(person2.sayName===person2.sayName);//true
}
上述方法总的来说,就是将类的成员函数定义到prototype中,而将会根据具体对象而不同的成员属性放到构造函数中
动态原型模式:把上述prototype定义的成员函数,以动态(惰性加载)的方式定义到构造函数中
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
if(typeof this.sayName != "function"){
Person.prototype.sayName = function(){
alert(this.name);
};
}
}
var person = new Person("nicholas",29,"Software Engineer");
person.sayName();
在这种情况下,prototype中的sayName()方法会在第一次调用 new Person()时才被指定
编外:寄生构造函数模式 返回对象与构造函数或者构造函数的原型属性之间没有关系
例:创建一个具有额外方法的特殊数组
function SpecialArray(){
var values=new Array();
values.push.apply(values,arguments);
varlues.toPipedString=function(){
return this.join("|");
}
returnvalues;
}
var colors = new SpecialArray("red","blue","green");
alert(colors.toPipedString()); //"red|blue|green"
关于apply用法,请看下篇