首页 > 代码库 > ECMAScript面向对象(二)——之创建对象方法总结

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 无法访问内部属性

 

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