JS创建对象总结

一、Object构造函数/字面量

<script>
    var person1 = new Object();
    person1.name = 'qiurx';
    person1.sayName = function() {
        console.log(this.name);
    }
    person1.sayName();
</script>

<script>
    var person1 = {
        name : 'qiurx',
        sayName : function() {
            console.log(this.name);
        }
    }
    person1.sayName();
</script>

简单。
但这样创建很多对象，会产生很多重复代码（每个对象都要写代码重新加属性和方法），最早期的方法。
为了解决这个缺点，需要对重复内容进行抽象，就出现了工厂模式。
二、工厂模式
软件工程l领域广知的一种模式，抽象了创建具体对象的过程。ES6之前没有‘class’，则用函数来封装以特定接口创建对象的细节。

<script>
    function createPerson(name){
        var obj = new Object();
        obj.name = name;
        obj.sayName = function(){
            console.log(this.name);
        }
        return obj;
    }
    var person1 = createPerson('qiurx');
    person1.sayName();
    console.log(person1 instanceof Object);   //true
</script>

通过函数传参可以方便创建多个相似的不同对象，减少了重复代码。
但不能识别对象，所有实例都是Object类型。
然后就出现了构造函数模式。
三、构造函数模式
不同于Object、Array等原生构造函数，我们可以创建自定义构造函数，从而创建特定类型的对象。

<script>
    function Person(name){   //一半构造函数首字母大写作为区分
        this.name = name;
        this.sayName = function(){
            console.log(this.name);
        }
        console.log('执行了构造函数');
    }
    var person1 = new Person('qiurx');   //用new操作符实例化对象
    //要创建新对象，必须用new操作符（虽然构造函数也是函数，但不推荐和普通函数一样用）
    //否则属性方法会被添加到window对象，而不是指向当前实例化的这个对象。
    //1、创建一个新对象。2、将构造函数作用域赋值给新对象person1。
    //3、执行构造函数中代码。4、返回新对象。
    person1.sayName();   //qiurx
    console.log(person1.constructor);   //查看实例的构造函数属性，指向Person()
    console.log(person1 instanceof Object);   //true
    console.log(person1 instanceof Person);   //true
</script>

通过构造函数创建的对象的constructor（构造函数）属性，指向他的构造函数。所有对象都继承自Object，所以同时也是Object的实例。
实例可以标志为一种特定的自定义类型，解决了工厂模式的标识问题。
但同一对象的不同实例对象的相同方法不一样不等，冗余。

var person2 = new Person('xiaoqiu');
console.log(person1.sayName == person2.sayName);   //false

JS中所有都是对象包括函数，每定义一个函数，也就实例化了一个对象 。
使用构造函数创建对象，每个方法都在每个实例上创建了一次，创建多个同样功能的function完全没有必要，耗资源。
因此，又有一种解决方法，可以把构造函数中的方法提出来定义在外部。

<script>
    function Person(name){
        this.name = name;
        this.sayName = sayName;
    }
    function sayName(){
        console.log(this.name);
    }
    var person1 = new Person('qiurx');
    person1.sayName();   //qiurx
</script>

把函数定义在构造函数外部全局，构造函数内把方法赋值为全局函数，这样每个实例对象的方法指针都指向同一个全局方法，实现了共享。
但这样在全局定义函数就是为了被实例的对象调用，麻烦而且污染全局；而且如果构造函数有多个方法，要定义很多全局函数，构造函数无封装性可言。
然后，就出现了原型模式。
四、原型模式
每个函数创建出来都有一个prototype属性，是个指针，指向一个对象。这个对象包含所有实例可以共享的属性和方法，prototype就是通过调用构造函数而创建的那个对象实例的原型对象。

<script>
    function Person(){
        
    }
    //把所有属性方法都定义在原型中
    Person.prototype.name = 'qiurx';
    Person.prototype.sayName = function(){
        console.log(this.name);
    } 
    //也可以使用对象字面量的写法
    /* Person.prototype = {
        name : 'qiurx',
        sayName : function(){
            console.log(this.name);
        },
    };
    Object.defineProperty(Person.prototype,"constructor",{   //TODO这里不知道是啥
    enumerable:false,
    value:Person,
    }); */
    var person1 = new Person();
    var person2 = new Person();
    console.log(person1.sayName() == person2.sayName());   //qiurx,qiurx,true
</script>

原型可以让所有实例实现属性和方法的共享。
但是，这样省略了实例对象传参初始化参数，所有实例对象创建完属性都已默认；而且因为属性的共享，对于引用数据类型的属性（引用会指向同一内存地址），一个实例修改引用内的值也会影响到其他实例（引用重定向不会影响到其他实例）。这也是原型模式很少被单独使用的原因。

<script>
    function Person(){
        
    }
    //把所有属性方法都定义在原型中
    Person.prototype.attr = {
        name : 'qiurx',
        age : '24'
    };
    Person.prototype.sayName = function(){
        console.log(this.attr.name);
    }
    var person1 = new Person();
    var person2 = new Person();
    person1.attr.name = 'xiaoqiu';
    person1.sayName();   //xiaoqiu
    person2.sayName();   //xiaoqiu
    person1.attr = {   //引用重定向不影响
        name : 'qiurx'
    };
    person1.sayName();   //qiurx
    person2.sayName();   //xiaoqiu
</script>

然后，又出现了另一种模式。
五、组合使用构造函数模式和原型模式
创建自定义类最常用的方法。
构造函数用于定义实例属性；原型模式用于定义共享的方法和属性。这样做，每个实例都有自己一份属性，而且可以通过构造函数传参初始化这些属性；同时公共的方法又实现了贡献节省内存。

<script>
    function Person(name){
        this.name = name;
        this.course = ['语文'];
    }
    Person.prototype = {
        constructor:Person,
        sayCourse : function(){
            console.log(this.course);
        }
    }
    var person1 = new Person('qiurx');
    var person2 = new Person('qiurx');
    person1.course.push('数学');
    person1.sayCourse();   //['语文'，'数学']
    person2.sayCourse();   //['语文']
</script>

实例属性在构造函数中定义，实现每个实例有自己的私有属性，修改不影响其他；而共享属性constructor和共享方法在原型中定义。
配合使用最常用。

• 工作中遇到过的问题：
  构造函数或原型中的方法互相调用：this.方法，在给元素绑定事件调用实例对象方法时要注意下，直接事件后面的函数this会指向此元素对象（实际需要的是指向此对象实例），不能直接接对象的方法；要在后面的function里面调用实例对象的方法。

<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script typet="text/javascript" src="http://code.jquery.com/jquery-latest.js"></script>
    </head>
    <body>
        <input type="button" value="按钮"/>
        
        <script>
            function Person(name){
                this.name = name;
                this.course = ['语文'];
            }
            Person.prototype = {
                constructor:Person,
                sayCourse : function(){
                    this.sayName();
                    console.log(this.course);
                },
                sayName : function(){
                    console.log(this.name);
                }
            }
            var person1 = new Person('qiurx');
            $('input').click(function(){
                //这样，实例对象方法中的this指向此对象
                person1.sayCourse();   //qiurx ['语文']
            });
            $('input').on('click',function(){
                person1.sayCourse();   //qiurx ['语文']
            });
            //事件后面直接接的函数中的this会指向此元素对象，即input元素对象
            //$('input').click(person1.sayCourse);  //报错：this.sayName is not a function
            //$('input').on('click',person1.sayCourse);   //报错：this.sayName is not a function
        </script>
    </body>
</html>

混合模式写了构造函数还不够（相当于类吧），还需要额外进行原型的操作。对于其他语言的人来说会觉得别扭，即出现了动态原型模式。
六、动态原型模式
把所有信息都封装到构造函数中，包括原型。构造函数中同时使用了构造函数和原型，这就成了动态原型模式。

<script>
    function Person(name){
        this.name = name;
        if(typeof this.sayName != 'function'){   //判断是否已经初始化过原型
            Person.prototype.sayName = function(){   //只进行一次初始化
                console.log(this.name);
            }
        }
    }
    var person1 = new Person('qiurx');
    person1.sayName();   //qiurx 
    Person.prototype.sayName = function(){   //修改一下原型
        console.log('猜猜我是谁');
    }
    var person2 = new Person('xiaoqiu');
    person2.sayName();   //猜猜我是谁 
    Person.prototype = {
        sayName : function(){
            console.log('最新的话语，我重写了原型');
        }
    }
    var person3 = new Person('xiaoqiulll');
    person3.sayName();   //最新的话语，我重写了原型
    person1.sayName();   //猜猜我是谁 （联系断了）
    person2.sayName();   //猜猜我是谁 （联系断了）
</script>

• 注意（混合模式也一样）：如果要修改原型，不能用对象字面量的形式重写原型，即让新原型指向了新的内存地址，这会切断现有实例和新原型的联系。

七、寄生的构造函数模式
略。
八、稳妥的构造函数模式
略。