<1>工厂模式:用函数来封装对象细节
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 a = createPerson("a",1,"a");
var b = createPerson("b",2,"b");
可以无数次调用这个函数,但是不能知道对象的类型
<2>构造函数模式
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayname = function()
{
alert(this.name);
};
}
var a = new Person("a",1,"a"); //new
var b = new Person("b",2,"b");
构造函数始终以一个大写字母开头
非构造函数以小写字母开头
a和b都保存着Person的一个不同实例,这两个对象都有
一个constructor属性,指向Person
创建自定义的构造函数将来可以把它的实例标识为一种特定的类型:a instanceof Person === true;
----构造函数与其他函数的区别:调用方式不同-----
构造函数要用new来调用!!!!
-------当作构造函数使用------
var a = new Person("a",1,"a");
a.sayname(); //a
-------当作普通函数使用------
Person("a",1,"a"); //添加到window
window.sayname(); //a
---------在另一个对象的作用域中调用---------
var o = new Object();
Person.call(o,a,21,a);
o.sayname(); //a
-------------构造函数的缺点-------------
每个方法都要在每个实例上重新创建一遍
a跟b都有一个名为sayname()的方法,但这两种方法不是同一个Function实例
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayname = new Function("alert(this.name);");
}
不同实例上的同名函数是不相等的。
alert(a.sayname == b.sayname); //false
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayname = sayname; //sayname的属性等于全局的sayname函数
}
function sayname(){
alert(this.name);
}
这样sayname包含一个指向函数的指针,a,b就共享在全局作用域中定义的同一个sayname()函数
但这样子,如果对象需要定义很多方法,那么就需要定义很多个全局函数,那么就失去了封装性
<3>原型模式
每一个函数都有一个prototype属性,这个属性是一个指针,指向一个对象
这个prototype的属性值是一个对象(属性的集合,再次强调!),默认的只有一个叫做constructor的属性,指向这个函数本身
function Person(){
}
Person.prototype.name = "a";
Person.prototype.age = 21;
Person.prototype.job = "IT";
Person.prototype.sayname = function(){
alert(this.name);
}
var person1 = new Person();
person1.sayname(); //a
var person2 = new Person();
person2.sayname(); //a
alert(person1.sayname == person2.sayname); //true
person1和person2访问的是同一组属性和同一个sayname()函数
当给对象实例添加一个属性时,这个属性会屏蔽原型对象中保存的那个同名属性
---------更简单的原型语法----------
function Person{
}
Person.prototype = {
name:"a", //逗号
age :21,
job: "a"
sayname:function(){
alert(this.name);
}
};
不过这样constructor就不指向Person了
所以可以这样修改
function Person{
}
Person.prototype = {
constructor:Person,
name:"a", //逗号
age :21,
job: "a"
sayname:function(){
alert(this.name);
}
};
----实例中的指针指向原型,不指向构造函数------
原型模式的缺点:
原型中所有的属性是被很多实例共享的
function Person{
}
Person.prototype = {
constructor:Person,
name:"a", //逗号
age :21,
job: "a"
friends:["x","y"],
sayname:function(){
alert(this.name);
}
};
var person1 = new Person();
var person2 = new Person();
Person1.friends.push("z");
alert(Person1.friends); //"x,y,z"
alert(Person2.friends); //"x,y,z"
alert(Person1.friends === Person2.friends); //true
<4>构造函数模式 + 原型模式
构造函数:实例属性
原型模式:定义方法和共享的属性
function Person(name,age,job){
this.name = name; //分号
this.age = age;
this.job = job;
this.friends = ["x","y"];
}
Penson.prototype = {
constructor:Person, //逗号
sayname:function(){
alert(this.name);
}
}
var person1 = new Person("a",21,"a");
var person2 = new Person("b",22,"b");
person1.friends.push("z");
alert(Person1.friends); //"x,y,z"
alert(Person2.friends); //"x,y"
alert(Person1.friends === Person2.friends); //false
alert(Person1.sayname === Person2.sayname); //true
<5>动态原型模式
不把构造函数和原型分开,而是把所有信息封装在构造函数中,
在构造函数中初始化原型。
function Person(name,age,job){
//属性
this.name=name;
this.name = name; //分号
this.age = age;
this.job = job;
//方法
if(typeof this.sayname != "function"){
Person.prototype.sayname = function(){
alert(this.name);
}
}
}
<6>寄生构造函数模式:封装 跟工厂模式一模一样,除了用new操作和把使用包装函数叫做构造函数
function Person(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 a = new Person("a",1,"a"); //new!!!!!!
a.sayname();
<7>稳妥构造函数模式
①新创建对象的实例方法不引用this
②不使用new操作符调用构造函数
function Person(name,age,job){
//创建要返回的对象
var o=new Object();
//可以在这里定义私有变量和函数
//添加方法
o.sayName=function(){
alert(name);
};
return o;
}
除了调用sayName()方法外,没有别的方法可以访问其他数据成员。
1152



被折叠的 条评论
为什么被折叠?



