创建js对象可以使用多种模式，每种模式有着不同的特点：如下：
1.工厂模式：创建一个函数，在函数中实例化一个对象，当每次调用函数时，就实例化一个对象，并返回这个对象；
我们知道，对象是引用形式的，每次实例化一个对象，就是在内存中开辟一个内存空间，所以每次实例化出来的内存空间是不一样的
一旦执行完调用，就是一个返回一个新对象，和原先调用的函数对象没有关系了
1 <script>
2 function createPeraon(name, age, job) {
3 var o = new Object();
4 o.name = name;
5 o.age = age;
6 o.job = job;
7 o.sayName = function() {
8 console.log(this.name);
9 }
10 return o;
11 }
12
13 var person1 = createPeraon('huanying2015', 25, '程序员工程师');
14 var person2 = createPeraon('aluoha', 26, '架构师');
15 person1.sayName();
16 person2.sayName();
17 </script>
备注：解决了创造多个相似对象的问题
2. 构造函数模式：
函数也是对象，创建一个函数，然后对这个函数的属性和方法进行设置。当需要新对象时，直接实例化这个对象函数，在实例化的时候，一起初始化必要属性，这样，就生成了一个新的对象，构造函数的属性和方法在实例化的新对象中都有，只是对参数进行了初始化
构造函数中，没有返回值
所以，构造函数要想创建新对象，就需要使用 new 来调用
1 <script>
2 function Person(name, age, job) {
3 this.name = name;
4 this.age = age;
5 this.job = job;
6 this.sayName = function() {
7 console.log(this.name);
8 }
9 }
10 var aa = Person('nanna', 18, '学生');
11 console.log(aa); // undefined 没有返回值
12 var person1 = new Person('huanying2015', 25, '程序员工程师');
13 var person2 = new Person('aluoha', 26, '架构师');
14 person1.sayName();
15 person2.sayName();
16 </script>
备注：构造函数的问题，是每个方法都要在实例上重新创建一遍，这样就会造成很多浪费
3.原型模式：
我们把对象的属性和方法都放到函数原型上，这样，在调用的时候，不必重新创建属性和方法，直接就可以调用了；
原型上的属性和方法可以实现共享
1 <script>
2 function Person() {};
3 Person.prototype.name = "huanying2015";
4 Person.prototype.age = 25;
5 Person.prototype.job = "架构师";
6 Person.prototype.sayName = function() {
7 console.log(this.name);
8 }
9 var person1 = new Person();
10 person1.sayName();
11 var person2 = new Person();
12 person2.sayName();
13 console.log(person1.sayName == person2.sayName)
14 </script>
备注：缺点：引用类型的属性如果进行修改，会影响其它实例的结果，因为都指向同一个内存空间
4.构造+原型模式
综合构造和原型模式：把私有属性和方法放在构造函数中，把共有属性和方法放在原型中，这样，私有属性和方法的修改，只会影响操作对象的本身，不会对其他实例造成影响
1 <script>
2 function Person(name, age, job) {
3 this.name = name;
4 this.age = age;
5 this.job = job;
6 this.friends = ['hali', 'jack'];
7 }
8 Person.prototype = {
9 constructor: Person,
10 sayName: function() {
11 console.log(this.name);
12 }
13 }
14
15 var person1 = new Person('huanying2015', 25, '首席架构师');
16 var person2 = new Person('aluoha', 27, '常务事务官');
17
18 person1.sayName();
19 person2.sayName();
20 console.log(person1.sayName == person2.sayName);
21 person1.friends.push('zhangsan');
22
23 console.log(person1.friends);
24 console.log(person2.friends);
25 </script>
5. 动态原型模式：
把所有信息都封装在构造函数中，通过在构造函数中初始化原型（在必要的情况下），又保持了同时使用构造函数和原型的优点。即可以通过先检查某个方法是否 存在有效，来决定是否需要初始化原型
<script>
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.friends = ['hali', 'jack'];
if (typeof this.sayName != "function") {
Person.prototype.sayName = function() {
console.log(this.name);
}
}
}
var person1 = new Person('huanying2015', 25, '首席架构师');
var person2 = new Person('aluoha', 27, '常务事务官');
person1.sayName();
person2.sayName();
console.log(person1.sayName == person2.sayName);
</script>
6.寄生构造函数模式：
1 <script>
2 function Person(name, age, job) {
3 var o = new Object();
4 o.name = name;
5 o.age = age;
6 o.job = job;
7 o.sayName = function() {
8 console.log(this.name);
9 }
10 return o;
11 }
12
13 var person1 = new Person('huanying2015', 25, '首席架构师');
14 person1.sayName();
15 </script>
这里：和工厂模式类似，只是使用new 来调用。引申一下，如下：
1 <script>
2 function Person() {
3 var values = new Array();
4 values.push.apply(values, arguments); // 借用数组的方法，将arguments 压入数组对象中
5 values.toPipedString = function() { // 数组对象的方法
6 return this.join("---->");
7 }
8 return values;
9 }
10
11 var person1 = new Person('huanying2015', 25, '首席架构师');
12 console.log(person1.toPipedString());
13 </script>
备注：返回的对象与构造函数，及构造函数的原型之间，没有任何关系，所以，不能使用instanceof 操作符来确定对象类型
7.稳妥构造函数模式：（这里没有搞懂，是瞎写的，以后再来修改）
稳妥构造模式遵循与寄生构造模式类似的模式，也有不同：1.新创建对象的方法，不引用this；2.不使用构造函数调用构造函数
1 <script>
2 function Person(name, age, job) {
3 var o = new Object();
4 o.name = name;
5 o.age = age;
6 o.job = job;
7 o.sayName = function() {
8 console.log(name);
9 }
10 return o;
11 }
12
13 var person1 = Person('huanying2015', 25, '首席架构师');
14 person1.sayName();
15 </script>
