创建对象

工厂模式

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

}

没有解决对象识别的问题，即怎样知道一个对象的类型。

构造函数模式

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    }
}

没有显示的创建对象，直接将属性和方法赋给了this对象，没有return语句

new一个实例经历以下四个步骤：创建一个新对象，将构造函数的作用域赋给新对象（this就指向该对象）；执行构造函数中的代码；返回新对象。

instanceof操作符可以检测对象类型。新创建的对象既是Object的实例，又是Person的实例

缺点：每个方法都要在每个实例上重新创建一遍。每个Person实例都包含一个不同的Function实例，会导致不同的作用域链和标识符解析。

为了解决这个问题

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName =sayName;
}

function sayName(){

alert(this.name);

}

将sayName（）函数的定义转移到构造函数外部，但是这样不太好。

原型模式

functionPerson(){

                       Person.prototype.name= 'nina';

                       Person.prototype.age= 29;

                       Person.prototype.job= "soft";

                       Person.prototype.sayName =function(){

                                alert(this.name);

                       }

             }

             varperson1 = new Person();

好处：可以让所有对象实例共享它所包含的属性和方法。

 //原型对象的问题。对于包含引用类型的属性来说，修改该属性会反映到所有实例上，这样每个实例就没有自己所特有的属性了

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

用构造函数来定义实例的属性，用原型定义实例的方法

function Person(name,age,job){

                       this.name= name;

                       this.age= age;

                       this.job= job;

                       this.friends= ['jadu',

                       'jjd'];

             }

             Person.prototype= {

                       constructor:Person,

                       sayName:function(){

                                console.log(this.name);

                       }

             }

动态原型模式

function Person(name,age,job){

                       this.name = name;

                       this.age = age;

                       this.job = job;

                       if(typeof this.sayName != 'function'){

                                Person.prototype.sayName = function(){

                                         console.log(this.name);

                                };

                       }

             }

  var friend = newPerson('nina',29,'soft');

  friend.sayName();

寄生构造函数模式

function Person(name,age,job){

                       var o = new Object();

                       o.name = name;

                       o.age = age;

                       o.job = job;

                       o.sayName = function(){

                                alert(this.name);

                       };

                       return o;          }

基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象。

//缺点：返回的对象与构造函数或者与构造函数的原型属性之间没有关系。也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此，不能用instanceof操作符来确定对象类型  

稳妥构造函数模式

function Person(name,age,job){

                       var o = new Object();

                       o.name = name;

                       o.age = age;

                       o.job = job;

                       o.sayName = function(){

                                alert(name);

                       };

                       return o;

             }

指的是没有公共属性，而且其方法也不引用this的对象。与寄生构造函数有两点不同：一是新创建对象的实例方法不引用this  二是不适用new操作符调用构造函数