JS对象

1. 属性

   1. Configurable: 表示能否通过 delete 删除属性从而重新定义属性，能否修改属性
      的特性，或者能否把属性修改为访问器属性，设置为false后，在设置除Writable就会      
   
      有错误。
   
   2. Enumerable: 表示能否通过 for-in 循环返回属性。
   
   3. Writable: 表示能否修改属性的值
   
   4. Value: 包含这个属性的数据值
   
   5. Object.defineProperty()：可以修改以上属性，三个参数:属性所在的对象、属
   
      性的名字和一个描述符对象。
   
      var person = {};
   
       Object.defineProperty(person, "name", {
   
        writable: false,
   
        value: "Nicholas"
   
       });

    

   
   6. 
   

2. 访问器属性
   注意点：

   1. 访问器属性不包含数据值;
   2. 它们包含一对儿 getter 和 setter 函数(不过，这两个函数都不是必需的)。 
   
   3. 在读取访问器属性时，会调用 getter 函数，这个函数负责返回有效的值;
   
   4. 在写入访问器属性时，会调用 setter 函数并传入新值，这个函数负责决定如何处理数据。

    

   属性

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

    

   例子：

   var book = {
   
       _year: 2004,
   
       edition: 1 
   
   };
   
   Object.defineProperty(book, "year", {
   
       get: function(){
   
           return this._year;
   
       },
   
       set: function(newValue){
   
           if (newValue > 2004) {
   
               this._year = newValue;
   
               this.edition += newValue - 2004;
   
   } }
   
   });
   
   book.year = 2005; 
   
   alert(book.edition); //2
   
   🐷：可以把“years”写成一个对象，{_year: {Value：...}}

    

3. 创建对象

   1. 工厂函数

     function createPerson(name) {
   
           var o = new Object();
   
           o.age = age;
   
           o.sayName = function () {...}
   
       }

    

   
   2. 构造函数（this）
   

       过程：
   
       (1) 创建一个新对象;
   
       (2) 将构造函数的作用域赋给新对象(因此 this 就指向了这个新对象);
   
       (3) 执行构造函数中的代码(为这个新对象添加属性);
   
       (4) 返回新对象。
   
       注意：
   
      （1）作为普通函数：属性和方法都被添加给 window 对象
   
       (2) 构造函数问题：就是每个方法都要在每个实例上重新创建一遍

    

   
   
   3. 原型模式
   

     （1）每个函数都有一个 prototype(原型)属性
   
     （2）只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个 
   
         prototype 属性，这个属性指向函数的原型对象。在默认情况下，所有
   
         原型对象都会自动获得一个 constructor (构造函数)属性，这个属性
   
         包含一个指向 prototype 属性所在函数的指针。
   
     （3）Object.getPrototypeOf(实例) // 返回实例的原型
   
     （4）Object.keys() for ...in 便利可数的
   
      (5) Object.getOwnPropertyNames() //所有的属性，无论是否可数
   
     （6）缺点：1⃣️ 它省略了为构造函数传递初始化参数这一环节，结果所有实
   
         例在 默认情况下都将取得相同的属性值
   
         2⃣️ 引用类型的数据会被所有实例共享
   
     （7）构造函数模式用于定义实 例属性，而原型模式用于定义方法和共享
   
         的属性。
   

   　　

   
   
   4. 动态原型模式(构造函数+原型写在一起)
   

    function Person（name，age，job）{
   
       this.name = name;
   
       this.age = age;
   
       this.job = job;
   
       if (typeof this.sayName != "function") {
   
           Person.prototype.sayName = function() {
   
               alert(this.name)
   
           }
   
       }
   
    }
   

   　　

   5.寄生构造函数模式:创建一个函数，该函数的作用仅仅是封装创建对象的代
   
   码，然后再返回新创建的对象,稳妥构造函数模式不使用new，不使用this
   

   function Person(name, age, job){
   
       var o = new Object();
   
       o.name = name;
   
       o.age = age;
   
       o.job = job;
   
       o.sayName = function(){
   
           alert(this.name);
   
       };
   
   return o; }
   
   var friend = new Person("Nicholas", 29, "Software Engineer");
   
   friend.sayName();  //"Nicholas"

    

4. 继承

   1. 确定原型和实例的关系
   （1）instanceof， 实例 idstanceof Person
   
   （2）isPrototypeOf Person.prototype.isPrototypeOf(p1)
   
   2. 原型链问题：包含引用类型值的原型
   
   3. 构造函数+原型 实线组合继承,会调用两次构造函数
   
   4. 原型式继承
   
       function object(0) {
   
           function F() {}
   
           F.prototype = o;
   
           return new F()
   
       }
   
   5. 寄生继承
   
       function createAnother(original) {
   
           var clone=object(original); //通过调用函数创建对象
   
           clone.sayHi = function(){
   
               alert("hi");
   
           };
   
           return clone;
   

   6. 寄生组合式继承

    function inheritPrototype(subType, superType){
   
       var prototype = object(superType.prototype);
   
       prototype.constructor = subType;
   
       subType.prototype = prototype;
   
       }