create-object

发表于

工厂模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;
    }
    
    var person1 = createPerson("Nicholas", 29, "Software Engineer");
    var person2 = createPerson("Greg", 27, "Doctor");
    
    person1.sayName();   //"Nicholas"
    person2.sayName();   //"Greg"

根据接受的参数创建一个包括所有必要信息的对象，但是无法解决对象识别的问题

构造函数模式

像 Object 和 Array 这样的原生构造函数，在运行时会自动出现在执行环境中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    };    
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
person1.sayName();   //"Nicholas"
person2.sayName();   //"Greg"
alert(person1 instanceof Object);  //true
alert(person1 instanceof Person);  //true
alert(person2 instanceof Object);  //true
alert(person2 instanceof Person);  //true
alert(person1.constructor == Person);  //true
alert(person2.constructor == Person);  //true
alert(person1.sayName == person2.sayName);  //false

过程如下：

  1. 创建一个新对象
  2. 将构造函数的作用域赋给新对象，所以 this 指向新对象。
  3. 执行构造函数中的代码，为这个新对象添加属性。
  4. 返回新对象

主要问题：因为 sayName 这个函数被创建了两个？？？。。。

原型模式

每个函数都有一个 prototype（原型）属性，这个属性是指针，指向一个对象，包含可以由特定类型的所有实例共享的属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function Person(){
       }
       
       Person.prototype.name = "Nicholas";
       Person.prototype.age = 29;
       Person.prototype.job = "Software Engineer";
       Person.prototype.sayName = function(){
           alert(this.name);
       };
       
       var person1 = new Person();
       person1.sayName();   //"Nicholas"
       
       var person2 = new Person();
       person2.sayName();   //"Nicholas"
     
       alert(person1.sayName == person2.sayName);  //true
       
       alert(Person.prototype.isPrototypeOf(person1));  //true
       alert(Person.prototype.isPrototypeOf(person2));  //true
       
       //only works if Object.getPrototypeOf() is available
       if (Object.getPrototypeOf){
           alert(Object.getPrototypeOf(person1) == Person.prototype);  //true
           alert(Object.getPrototypeOf(person1).name);  //"Nicholas"
       }

…所有实例共享同一个属性和方法。

构造函数模式 + 原型模式

最常见的方式就是这个，构造函数用于定义实例属性，原型模式用于定义方法和共享的属性。
默认就是这中啦。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function Person(name, age, job){
          this.name = name;
          this.age = age;
          this.job = job;
          this.friends = ["Shelby", "Court"];
      }
      
      Person.prototype = {
          constructor: Person,
          sayName : function () {
              alert(this.name);
          }
      };
      
      var person1 = new Person("Nicholas", 29, "Software Engineer");
      var person2 = new Person("Greg", 27, "Doctor");
      
      person1.friends.push("Van");
      
      alert(person1.friends);    //"Shelby,Court,Van"
      alert(person2.friends);    //"Shelby,Court"
      alert(person1.friends === person2.friends);  //false
      alert(person1.sayName === person2.sayName);  //true