6.1 理解对象
6.1.1 属性类型
6.1.2 读取多个属性
6.1.3 读取属性的特性
6.2 创建对象
6.2.1 工厂模式
6.2.2 构造函数模式
6.2.3 原型模式
6.2.4 组合使用构造函数模式和原型模式
6.2.5 动态原型模式
6.2.6 寄生构造函数模式
6.2.7 稳妥构造函数模式

6.1 理解对象

创建对象的两种方式（尽量用第二种）

        //第一种创建对象的方式（几乎不用）
        var person = new Object();
        person.name = "Nicholas";
        person.age = 29;
        person.job = "Software Engineer";

        person.sayName = function(){
            console.log(this.name);
        }

        //第二种，字面量形式创建对象
        var person = {
            name:"Nicholas",
            age:29,
            job:"Software Engineer",

            sayName : function(){
                console.log(this.name);
            }
        };

6.1.1 属性类型

1.数据属性

使用Object.defineProperty()方法

数据属性包含一个数据值的位置。在这个位置可以读取和写入值。
1 . [[Configurable]]：表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。默认值true。
2 . [[Enumerable]]：表示能否通过 for-in 循环返回属性。默认值true。
3 . [[Writable]]：表示能否修改属性的值。默认值为true。
4 . [[Value]]：包含这个属性的数据值。读取属性值的时候，从这个位置读；写入属性的时候，把新值保存到这个位置。默认值是undefined。
要修改上述属性默认的特性，必须使用Object.defineProperty()方法。这个方法包含三个参数 ：属性所在的对象、属性的名字和一个描述符对象。其中描述符对象的属性必须是：configurable、enumerable、writable和value。设置其中的一或多个值，可以修改对应的特性值。

        var person = {};
        Object.defineProperty(person,"name",{
            writable:false,
            value:"Nicholas"
        });

        console.log(person.name);
        person.name = "Greg";
        console.log(person,name);

2.访问器属性

使用Object.defineProperty()方法

访问器属性不包含属性值，访问访问器属性时调用getter函数，写入访问器属性时调用setter函数
1 . [[Configurable]]：表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。默认值true。
2 . [[Enumerable]]：表示能否通过 for-in 循环返回属性。默认值true。
3 . [[Get]]：在读取属性时调用的函数。默认值undefined。
4 . [[Set]]：在写入属性时调用的函数。默认值undefined。

        var book = {
            _year : 2019,      //_year下划线是一种常用的记号，等同于year
            edition:1
        }

        Object.defineProperty(book,"year",{
            get:function(){
                return this._year;
            },
            set:function(newValue){
                if(newValue > 2019){
                    this._year = newValue;
                    this.edition += newValue - 2019;
                }
            }
        })

        book.year = 2020;    //写入属性值，调用setter函数
        console.log(book.edition);      //控制台输出2

6.1.2 读取多个属性

使用Object.defineProperties()方法

        //定义多个属性
        var book = {}
        Object.defineProperties(book,{
            _year: {
                value:2019
            },

            edition: {
                value:1
            },

            year: {
                get: function(){
                    return this.year;
                },

                set: function(newValue){
                    if (newValue > 2004){
                        this._year = newValue;
                        this.edition += newValue - 2019;
                    }
                }
            }
        });

6.1.3 读取属性的特性

使用Object.getOwnPropertyDescriptor()方法

//接 6.1.2的代码
var descriptor = Object.getOwnPropertyDescriptor(book, "_year"); 
alert(descriptor.value);         //2019
alert(descriptor.configurable); //false 

6.2 创建对象

之前构造函数和字面量形式创建有一个非常的缺点：一个接口创建对象时会产生大量的代码冗余。因此使用工厂模式。

6.2.1 工厂模式

ECMAScript中无法创建类，因此用函数来封装以特定的接口创建对象的细节。

        function createPerson(name,age,job){
            var o = new Object();
            o.name = name;
            o.age = age;
            o.job = job;
            o.sayName = function(){
                console.log(this.name);
            };
            return o;    //返回对象
        }

        var person1 = createPerson("Lisi",22,"Software Engineer");
        var person2 = createPerson("zhangsan",25,"Doctor");

6.2.2 构造函数模式

    function Person(name,age,job){
        this.name = name;
        this.age = age;
        this.job = job;
        this.sayName = function(){
            console.log(this.name);
        };
    }

    var person1 = new Person("Lisi",22,"Software Engineer");
    var person2 = new Person("zhangsan",25,"Doctor");

6.2.3 原型模式

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

6.2.4 组合使用构造函数模式和原型模式

    function Person(name,age,job){
        this.name = name;
        this.age = age;
        this.job = job;
        this.friends = ["Shellby", "Court"];
    }

    Person.prototype = {
        constructor : Person,
        sayName : function(){
            console.log(this.name);
        }
    }

    var person1 = new Person("Zhangsan",22,"Software Engineer");
    var person2 = new Person("Lisi",25,"Doctor");

    person1.friends.push("Van");
    console.log(person1.friends);       //["Shellby", "Court","Van"]
    console.log(person2.friends);       //["Shellby", "Court"]
    console.log(person1.sayName === person2.sayName);       //true

6.2.5 动态原型模式

6.2.6 寄生构造函数模式

这个模式其实与工厂模式是一样的

    function Person(name,age,job){
        var o = new Object();
        o.name = name;
        o.age = age;
        o.job = job;
        o.sayName = function(){
            console.log(this.name);
        };
        return o;
    }

    var friend = new Person("Zhangsan",22,"Software Engineer");
    friend.sayName();       //Zhangsan

6.2.7 稳妥构造函数模式

    function Person(name,age,job){
        //创建要返回的对象
        var o = new Object();

        //可以在这里定义私有变量和函数

        //添加方法
        o.sayName = function(){
            console.log(name);
        }

        //返回对象
        return o;
    }

    var friend = new Person("Zhangsan",22,"Software Engineer");
    friend.sayName();       //Zhangsan