ECMAScript面向对象(二)——之创建对象方法总结

创建对象的方法

1.  工厂模式

 缺点：无法识别对象的类型，因为根本没有定义新的对象类型

// 工厂模式创建对象
  //定义
function createPerson(name,age,job){
    var o=new Object();
    o.name=name;
    o.age=age;
    o.job=job;
    o.sayHi=function(){console.log('Hi!')};

    return o;
}
//使用
 var p1=createPerson("JayChou","28","歌手");

　　2.构造函数模式

 缺点：创建对象实例的时候其实每个属性和方法都要重新创建一份。造成即使是同一个对象创建的实例，但是它们相同的方法并非相等。

 因为作用域链和标识符解析不同。

// 构造函数模式
  //定义
function Person(name,age,job){
    this.name=name;
    this.age=age;
    this.job=job;
    this.sayHi=function(){console.log('Hi!')};
}
 //使用
  var p11=new Person("JayChou","28","歌手");
  var p12=new Person("JayChou","29","歌手");
   
   console.log(p11.sayHi==p12.sayHi);//false

　　3.原型模式

利用函数的原型指针属性：prototype 指向一个对象。这个对象是由特定类型的所有实例共享的属性和方法。

缺点：如果属性中有引用类型，那么在任何一个实例中，对引用类型的属性进行操作会影响到所有的实例该引用类型。

// 原型模式
function Person(){}
  
 Person.prototype={
   constructoe:Person,
   name:"koo",
   sex:"man",
   arr:[1,2,3],//引用类型的值，通过引用访问
   sayHi:function(){
       console.log("Hi!");
   }
 };
  var obj=new Person();
  var obj1=new Person();
  obj1.name="sss";
  obj1.arr.push(5);
  console.log(obj.name);// koo
  console.log(obj1.name);// sss

  console.log(obj.arr);//1,2,3,5
  console.log(obj1.arr);//1,2,3,5

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

      综合构造函数和原型的特性，使用构造函数定义实例特有属性和方法，原型则定义共享属性和方法

// 构造原型组合模式
function Person(name,age,job){
    this.name=name; //实例特有属性写在构造函数中
    this.age=age;
    this.job=job;
    this.arr=[1,2,3];
}

// 实例公共属性和方法写在原型中
Person.prototype.sayHi=function(){console.log('say Hi!')};

//使用
var person1=new Person("Jay",28,"歌手");
person1.arr.push(20);
console.log(person1.arr);//[1,2,3,20]
var person2=new Person("coco",30,"歌手");
person2.arr.push(10);
console.log(person2.arr);//[1,2,3,10]

　　5.动态原型模式

和上面的组合模式相似，只是将原型公共属性的定义写在构造函数的内部。

// 动态原型模式
function Person(name,age,job){
    this.name=name; //实例特有属性写在构造函数中
    this.age=age;
    this.job=job;
    this.arr=[1,2,3];

  if (typeof this.sayHi !="function") {
      // 实例公共属性和方法写在原型中,但是这里不能用字面量的形式定义
    Person.prototype.sayHi=function(){console.log('say Hi!')};
  }
}

　　6.寄生构造模式——一般用于扩展原生引用类型

这个模式和工程模式类似，只是在创建对象的时候，寄生模式还是使用new关键字方式。返回的对象不是new关键字生成的，而是通过return返回的，它覆盖了new生成的对象。
返回的对象与构造函数、构造函数的原型对象直接没有关系。

// 寄生构造函数模式 
//
function MyArray(){
   var o=new Array();
    o.toPipedString=function(){
        return this.join("|");
    };
    return o;
}

var arr=new MyArray();

console.log(arr instanceof MyArray);//false
console.log(arr instanceof Array);//true
console.log(arr instanceof Object);//true

 　　7.稳妥构造函数模式

这里类说说这个稳妥对象的概念。稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象。适合在那些禁止用new和this的场景中使用。

// 稳妥构造函数模式
function Person(name,age,job){
    var o=new Object();

    //私有属性
    name=name; 
    age=age;
    job=job;

    // 对外接口,只有这个接口可以访问内部属性
   o.sayHi=function(){
    console.log('hi，'+name);
  };
  return o;
}
var p1=Person("JayChou","29","歌手");
p1.sayHi();//hi，JayChou
console.log(p1.name);//undefined 无法访问内部属性