创建对象

工厂模式

解决了创建相似对象的问题，但没有解决对象识别的问题

function createPerson(name, age, job) {
    var o = new Object()
    o.name = name;
    o.age = age;
    o.sayName = function() {
        alert(this.name)
    }
   return o;
}
var person1 = createPerson('Lime', 26, 'Developer')

构造函数模式

解决了对象识别的问题，构造函数产生的实例拥有 Constructor 属性，指向构造函数。
存在问题，没必要在每一个实例中创建完成同样任务的不同Function

function Person(name, age, job) {
   this.name = name;
   this.age = job;
   this.sayName = function() {
      alert(this.name)
   }
}
var person1 = new Person('Lime', 26, 'Developer')

// 补充：在另一个作用域中调用构造函数
var o = new Object();
Person.call(o, 'Lime', 26, 'Developer')

组合构造函数

构造函数模式用于定义实例属性，而原型模式用于定义方法和共享属性。

function Person(name, age, job){
   this.name = name;
   this.age = age;
   this.job = job;
   this.friends = ["Shelly", "Court"]
}
Person.prototype = {
   constructor: Person,
   sayName: function(){
      alert(this.name)
   }
}
var person1 = new Person('Lime', 26, 'Developer')

动态原型模式

将组合构造函数中构造函数和原型封装在一整块

function Person(name, age, job){
   // 属性
   this.name = name;
   this.age = age;
   this.job = job;
   this.friends = ["Shelly", "Court"];
  
   //方法
   if(typeof this.sayName != "function") {
      Person.prototype.sayName = function() {
         alert(this.name)
      }
   }
}

继承

原型链

让一个引用类型继承另一个引用类型的属性和方法

function SuperType(){
   this.property = true;
}
SuperType.prototype.getSuperValue = function(){
   return this.property;
}

function SubType(){
   this.subproperty = false;
}

// 继承了SuperType
 SubType.prototype = new SuperType();

组合继承

使用原型链实现对原型属性和方法的继承，而通过借用构造函数实现对实例属性的继承
不足在于调用了两次超类型

function SuperType(name){
   this.name = name;
   this.colors = ["red", "blue", "green"]
}
SuperType.prototype.sayName = function(){
   alert(this.name)
}

function SubType(name, age){
    //继承属性
    SuperType.call(this, name)
    
    this.age = age
}

//继承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;

var instance = new SubType();

寄生组合式继承

不必为了指定子类型的原型而调用超类型的方法，所需要的只是超类型原型的一个副本

  function inherit(subType, superType){
     var prototype = Object.create(superType.protptype)          //创建对象
     prototype.constructor = subType                             //增强对象
     subType.prototype = prototype                               //指定对象
  }

function SuperType(name){
   this.name = name;
   this.colors = ["red", "blue", "green"]
}
SuperType.prototype.sayName = function(){
   alert(this.name)
}

function SubType(name, age){
    //继承属性
    SuperType.call(this, name)
    
    this.age = age
}

inherit(SubType, Supertype)

使用 new 操作符 时经历的四个阶段

Person(name) {
  this.name = name
}
var person1 = new Person()

1. 创建新的对象
2. 将构造函数的作用域赋给新对象，即this指代新对象
3. 执行构造函数中的代码
4. 返回新的对象