JavaScript创建对象的几种 方式

 //JavaScript创建对象的七种方式     
 //https://xxxgitone.github.io/2017/06/10/JavaScript%E5%88%9B%E5%BB%BA%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%83%E7%A7%8D%E6%96%B9%E5%BC%8F/   出处
        //--1.工厂模式
        function createPerson(name, job) {
            var o = new Object()
            o.name = name
            o.job = job
            o.sayName = function () {
                console.log(this.name)
            }
            return o;
        }
        var person1 = createPerson('Jiang', 'student');
        var person2 = createPerson('X', 'Doctor');
        //--//--

        //--2.使用构造函数创建对象
        function Person() {

        }
        var person1 = new Person()   //new关键字 后边必须是函数名
        person1.name = 'Jiang';
        console.log(person1.name) //Jiang

        person1 instanceof Object // true  //使用这个方式创建对象可以检测对象类型
        person1 instanceof Person //true
        //--//--

        //--3.原型模式
        function Person() {
        }
        Person.prototype.name = 'Jiang';
        Person.prototype.job = 'student';
        Person.prototype.sayName = function () {
            console.log(this.name)
        }
        var person1 = new Person()
        //--//--

        //--4.更简单的写法
        function Person() {
        }
        Person.prototype = {
            name: 'Jiang',
            job: 'student',
            sayName: function () {
                console.log(this.name)
            }
        }
        var person1 = new Person(); //将Person.prototype设置为等于一个以对象字面量形式创建的对象，但是会导致.constructor不在指向Person了。

        Person.prototype.constructor === Person  // false    //使用这种方式，完全重写了默认的Person.prototype对象，因此 .constructor也不会存在这里

        //如果需要 constructor 这个属性的话，可以手动添加
        function Person() {
        }
        Person.prototype = {
            constructor：Person,
                name: 'Jiang',
                job: 'student',
                sayName: function() {
            console.log(this.name);
            }
            };

        function Person() {
        }
        Person.prototype = {
                name: 'jiang',
            friends: ['Shelby', 'Court']
        }
        var person1 = new Person();
        var person2 = new Person();
        person1.friends.push('Van');
        console.log(person1.friends) //[“Shelby”, “Court”, “Van”]
        console.log(person2.friends) //[“Shelby”, “Court”, “Van”]
        console.log(person1.friends === person2.friends) // true

        //friends存在与原型中，实例person1和person2指向同一个原型，person1修改了引用的数组，也会反应到实例person2中
        //--//--

        //--5.组合使用构造函数模式和原型模式
        function Person(name) {
            this.name = name;
            this.friends = ['Shelby', 'Court'];
        }
        Person.prototype.sayName = function () {
            console.log(this.name);
        }
        var person1 = new Person();
        var person2 = new Person();
        person1.friends.push('Van');
        console.log(person1.friends);  //[“Shelby”, “Court”, “Van”]
        console.log(person2.friends);// [“Shelby”, “Court”]
        console.log(person1.friends === person2.friends); //false
        //--//--

        //--6.动态原型模式
        function Person(name, job) {
            // 属性
            this.name = name;
            this.job = job;
            // 方法
            if (typeof this.sayName !== 'function') {
                Person.prototype.sayName = function () {
                    console.log(this.name);
                }
            }
        }
        var person1 = new Person('Jiang', 'Student')
        person1.sayName();      ///只有在sayName方法不存在的时候，才会将它添加到原型中。这段代码只会初次调用构造函数的时候才会执行。
        //--//--

        //--7.寄生构造函数模式
        function Person(name, job) {
            var o = new Object()
            o.name = name;
            o.job = job;
            o.sayName = function () {
                console.log(this.name);
            }
            return o;
        }
        var person1 = new Person('Jiang', 'student');
        person1.sayName();   //这个模式，除了使用new操作符并把使用的包装函数叫做构造函数之外，和工厂模式几乎一样
        //构造函数如果不返回对象，默认也会返回一个新的对象，通过在构造函数的末尾添加一个return语句，可以重写调用构造函数时返回的值
        //--//--