javascript 创建对象的方式总结

<1>.基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)

var obj = new Object();

obj.name = "userObject";

obj.printName = function(name){

     this.name = name;

     console.log(this.name);

}

obj.printName("newUserObject");

<2>.工厂方式创建对象(每次创建一个object后，其中对应的方法(本例中是get)也被创建一次，事实上每个对象共享了同一个函数)：

[1].简单工厂模式

a.不带参数的构造方法

function Dog(){

    var dog = Object();

    dog.name = "xiaoHuang";

    dog.color = "Yellow";

    dog.get = function(){

          console.log(this.name+","+this.color);

    }

    return dog;

}

var dog1 = Dog();

var dog2 = Dog();

dog1.get();

dog2.get();

dog1.get() === dog2.get() // true;

b.带参数的构造方法

function Dog(name,color){

     var dog = Object();

     dog.name = name;

     dog.color = color;

     dog.get = function(){

          console.log(this.name+","+this.color);

     }

     return dog;

}

var dog1 = Dog("xiaoBlue","blue");

dog1.get();

c.让函数被多个创建的对象所共享，而不是每一个对象都创建一个相同的函数（缺点:对象定义本身和方法分离了）

function get(){

     console.log(this.name+","+this.color);

}

function Dog(name,color){

     var dog = Object();

     dog.name = name;

     dog.color = color;

     dog.get = get;

     return dog;

}

var dog1 = new Dog("xiaoRed","red");

var dog2 = new Dog("xiaoGreen","green");

dog1.get();

dog2.get();

dog1.get() === dog2.get();

<3>.混合工厂模式（创建假的构造函数，只返回另一种对象的新实例）

同样与简单工厂模式一样有三种方式

function Dog(){

     var dog = new Object();

     dog.name = "xiaoRed";

     dog.color = "red";

     dog.get = function(){

          console.log(this.name+","+this.color);

     }

     return dog;

}

与工厂方式所不同的是，这种方式使用new运算符。

<4>.构造函数方式

a.无参构造函数

function Person(){

     this.username = "zhangsan";

     this.pwd = "123";

     this.toString = function(){

          console.log(this.username+","+this.pwd);

     }

}

var person = new Person();

person.toString();

b.有参构造函数

unction Person(username,pwd){

     this.username = username;

     this.pwd = pwd;

     this.toString = function(){

          console.log(this.username+","+this.pwd);

     }

}

var person = new Person("xiaoHong","123456");

person.toString();

构造函数方式在函数内部没有创建对象，是用this关键字。因为在调用构造函数时已经创建了对象，而在函数内部只能用this来访问对象属性。
它同工厂方式一样。每次调用都会为对象创建自己的方法。

<5>.使用原型(prototype)方式创建对象

优点：创建的多个对象共享同一个方法(getInfo)

缺点：创建的多个对象在共享同一个方法的同时也共享了同样的属性(username,password)，实际开发中这样儿是不行的，必须是多个对象都要有自己的属性。采用该方式创建对象通常是用来扩展已有对象的某一个方法。

a.无参构造函数
function Person(){}
Person.prototype.username = "zhangsan";
Person.prototype.password = "123";
Person.prototype.getInfo = function(){
     console.log(this.username + ", " + this.password);
}
var person = new Person();
var person2 = new Person();
person.username = "lisi";
person.getInfo();
person2.getInfo();

b.利用原型方式有个很严重的问题，创建对象，生成的所有对象将会共享原型中的属性，这样一个对象改变了该属性也会反应到其他的对象上，例如数组

function Car(){
} 
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.arr = new Array("a","b");
Car.prototype.showColor = function(){
console.log(this.color);
} 
var car1 = new Car();
var car2 = new Car();
car1.arr.push("cc");
console.log(car1.arr);  //aa,bb,cc
console.log(car2.arr);  //aa,bb,cc

<6>.联合的构造函数/原型方式

 用构造函数/原型方式就可以像其他程序设计语言一样创建对象，是用构造函数定义对象的非函数属性，用原型方式定义对象的方法。

function Car(color,door){
   this.color = color;
   this.doors = door;
   this.arr = new Array("aa","bb");
}
Car.prototype.showColor=function(){
   console.log(this.color);
}
var car1 = new Car("red",4);
var car2 = new Car("blue",4);
car1.arr.push("cc");
console.log(car1.arr);  //aa,bb,cc
console.log(car2.arr);  //aa,bb

<7>.动态原型方式

动态原型的方式同混合的构造函数/原型方式原理相似。唯一的区别就是赋予对象方法的位置。

动态原型方式：在构造函数中通过标志量让所有对象共享一个方法，而每个对象拥有自己的属性。

function Person(){
  this.username = "zhangsan";
  this.password = "123";
  if(typeof Person.flag == "undefined"){
       Person.prototype.toString = function(){
               console.log(this.username + ", " + this.password);
       }
       Person.flag = true;
  }
}
var p = new Person();
var p2 = new Person();
p.toString();
p2.toString();

 动态原型方式是使用一个标志来判断是否已经给原型赋予了方法。这样可以保证该方法只创建一次