【js】js面向对象相关

创建一个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用法，请看下篇