javascript建立对象体式格局

• 工场形式

• 组织函数形式

• 原型形式

工场形式

    function createPerson(name, age){
        var obj = new Object();
        obj.name = name;
        obj.age = age;
        return obj; //一定要返回，不然打印undefined:undefined
    }
    var person1 = new createPerson('Young',18);
    console.log(person1.name + ':' + person1.age);

• 长处：工场形式能够处理建立多个类似对象

• 瑕玷：没有处理对象辨认题目（如何肯定一个对象的范例）

进修推断对象范例： http://www.cnblogs.com/flyjs/…

组织函数形式

    function Person(name,age){
      this.name = name;
      this.age = age;
    }
    var person1 = new Person('Young',18);
    console.log(person1.name + ':' + person1.age);

在说优瑕玷之前，先来说说她自身的一点小故事吧

将组织函数当作函数运用

    function Person(name,age){
      this.name=name;
      this.age=age;
      this.sayName=function(){
        return this.name;
      }
    }
    
    //当作组织函数运用
    var person1 = new Person('Young', 18);
    person1.sayName();
    console.log(person1.name + ':' + person1.age);
    
    //当作平常函数挪用
    Person('Wind', 18);
    console.log(window.sayName());
    
    //在另一个作用域中挪用
    var obj = new Object();
    Person.call(obj, 'bird', 100);
    console.log(obj.sayName());

组织函数优瑕玷

• 长处：能够将它的实例标识为一种特定范例

• 瑕玷：每一个要领都要在每一个实例上从新建立一遍。固然你也能够如许改：

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

改成挪用全局函数，如许一来毫无封装性可言。。。接下来的原型形式能够填补这个的不足

原型形式

    function Person(){
      
    }
    Person.prototype.name = 'Young';
    Person.prototype.age = 18;
    Person.prototype.sayName = function(){
      return this.name;
    }
    
    var person1 = new Person();
    console.log(person1.sayName());
    var person2 = new Person();
    console.log(person1.sayName());
    alert(person1.sayName === person2.sayName);
    //person1和person2接见的是统一组属性的统一个sayName()函数

虽然能够经由过程对象实例接见保存在原型中的值，但却不能经由过程实例对象重写原型中的值

    function Person(){
      
    }
    Person.prototype.name='Young';
    Person.prototype.age=18;
    Person.prototype.sayName=function(){
      return this.name;
    }
    
    var person1=new Person();
    var person2=new Person();
    person1.name='Wind';
    
    console.log(person1.sayName());//Wind
    console.log(person2.sayName());//Young
    alert(person1.sayName==person2.sayName);//true

在我们挪用person1.sayName的时刻，会前后实行两次搜刮，解析器先肯定实例person1是不是有sayName的属性，有则挪用本身的属性，没有则搜刮原型中的属性。

    function Person(){
      
    }
    Person.prototype.name='Young';
    Person.prototype.age=18;
    Person.prototype.sayName=function(){
      return this.name;
    }
    
    var person1=new Person();
    var person2=new Person();
    
    person1.name='Wind';
    console.log(person1.sayName());//Wind
    console.log(person2.sayName());//Young
    
    delete person1.name;
    console.log(person1.sayName());//Young
    console.log(person2.sayName());//Young

运用hasOwnPropertyType要领能够检测一个属性是存在与原型中照样存在于实例中，该要领是从Object继续来的，实例中为true，原型中为false。

罗列对象上的实例属性用Object.keys()要领

    function Person(){
      
    }
    Person.prototype.name='Young';
    Person.prototype.age=18;
    Person.prototype.sayName=function(){
      return this.name;
    }
    
    var keys=Object.keys(Person.prototype);
    console.log(keys);//["name", "age", "sayName"]

原型形式优瑕玷

• 长处：不必每一个要领都要在每一个实例上重申一遍

• 瑕玷：很少有人零丁运用原型形式地。。题目详列

    function Person(){
      
    }
    Person.prototype={
      constructor:Person,
      name:'Young',
      age:18,
      friends:['Big','Pig'],
      sayName:function(){
      return this.name;
      }
    };
    var p1=new Person();
    var p2=new Person();
    p1.friends.push('Mon');
    console.log(p1.friends);//["Big", "Pig", "Mon"]
    console.log(p2.friends);//["Big", "Pig", "Mon"]

恰是由于实例平常都要有本身的属性，而我们这里将他放在了Person.prototype中，所以跟着p1的修正，全部实例包含原型都修正了。那末，我们能够组合运用组织函数形式和原型形式。

组合运用组织函数形式和原型形式

    function Person(name,age){
      this.name=name;
      this.age=age;
      this.friends=['Big','Pig'];
    }
    Person.prototype={
      sayName:function(){
      return this.name;
      }
    };
    var p1=new Person('Young',18);
    var p2=new Person('Wind',78);
    p1.friends.push('Raganya');
    console.log(p1.friends);//["Big", "Pig", "Raganya"]
    console.log(p2.friends);//["Big", "Pig"]
    console.log(p1.friends==p2.friends);//false
    console.log(p1.sayName==p2.sayName);//true

这类形式是现在运用最普遍、认同度最高的一种建立自定义范例的要领。是用来定义援用范例的一种默许形式。