读javascript高级程序设计05-面向对象之创建对象

1.工厂模式

工厂模式是一种常用的创建对象的模式，可以使用以下函数封装创建对象的细节：

function CreatePerson(name,age){
var p=new Object();
  p.name=name;
  p.age=age;
  p.speak=function(){
  console.log("my name is "+p.name);
  }
  return p;
}

var p1=CreatePerson('Wang',15);
p1.speak();

var p2=CreatePerson("Li",18);
p2.speak();

特点：工厂模式实现了创建相似对象的功能，但是缺点是无法确定所创建出来对象的类型。

2.构造函数

①使用构造函数可以创建对象：

function Person(name,age){
  this.name=name;
  this.age=age;
  this.speak=function(){
  console.log("my name is "+this.name);
  }
}

构造函数和工厂模式区别的地方：没有在函数内显式的创建对象，而是直接将属性赋值给this；没有使用return语句返回。

②调用：使用new操作符调用构造函数创建对象。

//作为构造函数调用
var p1=new Person('Wang',15);
p1.speak();// my name is Wang
var p2=new Person("Li",18);
p2.speak();// my name is Li

调用过程经历了几个步骤：

• 创建一个新对象；
• 将构造函数的作用域赋给该对象，此时this也就指向了该对象；
• 执行构造函数中的代码；
• 返回该对象。

另外，构造函数也可以作为普通函数调用，此时this指向的是window对象：

Person('chen',15);
window.speak();//my name is chen

③调用构造函数创建的对象，既是Person的实例，也是Object的实例。这一点上比工厂模式略胜一筹。

console.log(p1 instanceof Object);//true
console.log(p1 instanceof Person);//true

④缺点：方法speak要在每个实例上都创建一遍,不能进行共享。

p1.speak==p2.speak;//返回false

3.原型模式

使用原型对象prototype的好处是可以让所有对象实例共享它所包含的属性和方法。

function Person(){
}

//原型
Person.protype={
  constructor:Person,
  name:'Tom',
  age:18,
  speak:function(){
  console.log('my name is '+this.name+',I am '+this.age);
  }
}

//调用
var p1=new Person();
var p2=new Person();
console.log(p1.speak==p2.speak);//true
console.log(p1.speak());//my name is Tom,I am 18

可以看出Person的实例对象共享了属性和方法。

isPrototypeOf()方法用来检测实例和原型对象之间的关系。

console.log(Person.prototype.isPrototypeOf(p1));//true

当给实例设置与原型中同名的属性时，会给该实例对象新增一个属性，它会屏蔽访问原型中的同名属性值但不会修改原型中的属性值。

p1.name='Cathy';
console.log(p1.name);//Cathy
console.log(p2.name);//Tom

如果想重新访问原型中的属性值，可以使用delete操作符删除实例属性即可。

delete p1.name;
console.log(p1.name);//Tom
console.log(p2.name);//Tom

hasOwnProperty()方法：用来检测某属性是存在于实例中还是存在于原型中。仅当属性存在于实例中时，才返回true。

in 操作符：只要对象存在某属性就返回true，无论是实例属性还是原型属性。

p1.hasOwnProperty('name')//false
"name" in p1;//true
p1.name='Cathy';
p1.hasOwnProperty('name')//true
"name" in p1;//true
p2.hasOwnProperty('name')//false
"name" in p2;//true
delete p1.name;
p1.hasOwnProperty('name')//false
"name" in p1;//true

结合使用hasOwnProperty和in，可以判断属性是不是存在于原型中。

function hasPrototypeProperty(object,name){
return (!object.hasOwnProperty(name))&&(name in object);
}
var p1=new Person();
console.log(hasPrototypeProperty(p1,'name'));//true
p1.name='Peter';
console.log(hasPrototypeProperty(p1,'name'));//false

原型的动态性：对原型所做的修改能够立即从实例中体现出来。

function Person(){
}
var p=new Person();
Person.prototype.speak=function(){
console.log("hello world");
}
p.speak();//hello world

原型模式缺点：实例之间共享所有的原型属性和方法，有些个性化的属性无法体现。

4. * 组合使用构造函数模式和原型模式

这种组合是最常见的一种方式，用构造函数模式创建实例属性，原型模式定义公用的属性和方法。

function Person(name,age)
{
  this.name=name;
  this.age=age;
  this.friends=['lucy','kate']
}
Person.prototype={
  constructor:Person,
  sayName:function(){
  console.log("my name is "+this.name);
  }
}
var p1=new Person('Ken',16);
p1.sayName();//my name is Ken
var p2=new Person('Peter',20);
p2.sayName();//my name is Peter
p1.friends.push('Zhang');
console.log(p1.friends);// ["lucy", "kate", "Zhang"]
console.log(p2.friends);// ["lucy", "kate"]

5.动态原型模式

function Person(name,age)
{
  this.name=name;
  this.age=age;
  if(typeof this.sayName!='function'){
      Person.prototype.sayName=function(){
      console.log("my name is "+this.name);
      }
  }
}
var p1=new Person('Ken',16);
p1.sayName();//my name is Ken
var p2=new Person('Peter',20);
p2.sayName();//my name is Peter

说明：不必检查原型中的每个属性和方法，只要检查其中一个即可；

不能使用对象字面量方法重写原型。