javascript创建对象的几种方式

一、字面量模式

var obj = {
  name:"terry",
  age:12,
  sayName:function(){
    console.log("my name is ",this.name);
  }
}

缺点: 对象是一次性的，复用性较差，如果要创建多个对象，代码冗余度太高

二、Object构造函数

//实例化一个对象
var obj = new Object();  //等价于 var obj = {};
//为实例化对象添加属性
obj.name = "terry";
obj.age = 12;
obj.sayName = function(){
  console.log("my name is",this.name);
}

缺点: 这种方式比较难看出是一个整体，且对象是一次性的，复用性较差，如果要创建多个对象，代码冗余度太高

三、工厂模式

因为创建具有同样接口的多个对象需要重复编写很多代码，为了使创建对象更加方便（不像字面量创建那样一次性），也为了写的代码更像个整体，可以使用工厂模式创建

// 1.创建一个函数 工厂函数
function createPerson(name,age,gender) {
    // 2.使用构造函数创建一个模板实例
    var person=new Object();
    // 3. 给模板实例赋值
    person.name=name;
    person.age=age;
    person.gender=gender;
    person.sayName=function () {
        console.log(this.name);
    }
    return person;  // 4. 返回一个实例对象
}
// 使用工厂函数创建实例
var p1=createPerson('zhangsan',19,'male')
var p2=createPerson('lisi',20,'female')

优点: 解决了创建多个类似（相同接口）对象的问题，减少代码冗余度

缺点: 不能识别对象类型（即无法用 instanceof 去判断）

四、构造函数模式

// 1. 使用函数来创建一个自定义的构造函数 function 函数表达式
function Person(name, age, gender) {
    // 2.直接使用this来进行一个赋值
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.sayName = function () {
      console.log(this.name);
    }
  }
// 3. 使用new操作符 创建一个实例
var p1=new Person('zhangsan',19,'male');
var p2=new Person('lisi',20,'female');

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

特点:

没有显式地创建对象。
属性和方法直接赋值给了 this。
没有 return

优点: 通过 instanceof 能够识别对象的类型

缺点:

每个方法都要在每个实例上重新创建一遍
可以将方法写在外部共享，但会造成全局作用域中定义多个函数，使全局作用域混乱

function Person(name, age, gender) {
  this.name = name;
  this.age = age;
  this.gender = gender;
  this.sayName = sayName;
}
//多个实例共享在全局作用域中定义的函数，解决了两个函数做同一件事的问题
//但会导致全局变量增多，造成污染,代码结构会混乱
function sayName() {
  console.log(this.name);
}
var person1 = new Person("zhangsan", 29, "male");
var person2 = new Person("lisi", 27, "female");
person1.sayName(); // zhangsan 
person2.sayName(); // lisi

五、原型模式

function Person() { }
// 直接在Person原型对象上进行属性和方法的定义
Person.prototype = {
    //当一个Person.prototype使用对象字面量赋值的时候 它的constructor指向就会发生改变(Object构造函数) 
    constructor: Person,
    name: "zhangsan",
    friends: ["lisi", "wangwu"],
    sayName() {
        console.log(this.name);
    }
};
var p1 = new Person();
var p2 = new Person();
console.log(p1.sayName == p2.sayName); // true
p1.name = "lisi";
console.log(p1.name); // lisi，来自实例
console.log(p2.name); // zhangsan，来自原型

优点: 属性和方法可以共享，并且可以在实例上重新定义属性，而不改变原型

缺点:

不支持参数的传递
由于共享，对于引用类型，一个实例的修改会导致其他实例访问值更改

var p1 = new Person();
var p2 = new Person();
p1.friends.push('xiaoming');
console.log(p1.friends);  //[ 'lisi', 'wangwu', 'xiaoming' ]
console.log(p2.friends);  //[ 'lisi', 'wangwu', 'xiaoming' ]

六、组合模式（构造函数+原型）

// 用构造函数保存实例属性（自己特有的）
function Person(name,age,gender){
    this.name=name;
    this.age=age;
    this.gender=gender;
    this.friends=['zhansan','lisi'];
}
// 用原型模式保存共享属性和方法 （共有的）
Person.prototype = {
    constructor: Person,
    sayName: function () {
        console.log(this.name);
    }
};

var p1=new Person('xiaohong',12,'male');
var p2=new Person('xiaoming',20,'male');
console.log(p1.friends===p2.friends); //false
p1.friends.push('wangwu');
console.log(p1.friends);  // [ 'zhansan', 'lisi', 'wangwu' ]
console.log(p2.friends);  // [ 'zhansan', 'lisi' ]
p1.sayName() // xiaohong
p2.sayName() // xiaoming
console.log(p1.sayName===p2.sayName); //true