//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语句，可以重写调用构造函数时返回的值

        //--//--