js扫盲---面向对象的程序设计

对象的属性

对象的属性分为两种： 数据属性(可直接定义)和访问器属性(必须通过Object.defineProperty()函数定义)。

• 数据属性的描述符：

  • [[Configurable]] : 能否通过delete删除；能否修改属性的特性；能否把属性改为访问器属性；一旦把此项改为false，则不能再改为true。
  • [[Enumerable]] : 可否枚举。for...in、Object.keys()、JSON.stringify()会忽略不可枚举的对象属性。
  • [[Writable]] : 能否修改属性的值。
  • [[Value]] : 数据属性的值

• 访问器属性的描述符：

  • [[Configurable]] : 同上。
  • [[Enumerable]] ： 同上。
  • [[Get]] : 在获取属性时，执行的函数。
  • [[Set]] : 再设置属性时，执行的函数。

• 设置对象的方法：

  • Object.defineProperty(obj, attr, descriptors)

  参数分别为： 属性所在的对象、属性的名字、描述符对象

       var person = {
           name: liyang
       };
       Object.defineProperty(person, 'name', {
           writable : false
       })
       person.name = 'kevin'；
       console.log(person.name);   // 'liyang'
  

  • Object.defineProperties(obj, obj)

       var person = {};
       // name前的下划线是一种常用的记号，表示只能通过对象方法访问的属性。
       // _name为数据属性，name为访问器属性
       Object.defineProperties(person, {
           _name: {    
               value: 'liyang',
               writable: true
           },
           name: {
               get: function(){
                   return this._name;
               },
                set: function(newVal){
                   return this._name = 'Mr/Miss ' + newVal;
               },               
           },
       })
       person.name = 'kevin';
       console.log(person.name);   // 'Mr/Miss kevin'
  

  • Object.getOwnPropertyDescriptor(obj, attr) : 用于读取属性的特性。

创建对象

• 工厂模式

  这种模式抽象了创建具体对象的过程。

      function createPerson(name, age){
          var o = new Object();
          o.name = name;
          o.age = age;
          return o;
      }
      var per1 = creatPerson(kevin, 24);
  

• 构造函数模式

      function Person(name, age){
          this.name = name;
          this.age = age;
          this.sayName = function(){
              console.log(this.name)
          }
      }
      var per1 = new Person(kevin, 24);
      var per2 = new Person(liyang, 23);
  

  • 构造函数的函数名一般以大写字母开头；
  • 要是用new操作符创建Person实例；
  • per1和per2都有constructor(构造函数)属性，指向Person；
  • instanceof 可以检测对象类型

        per1 instanceof Object;   // true
        per1 instanceof Person;   // true
    

  • 创建自定义的构造函数，意味着它的实例可以被标识为一种特殊类型（比如为Person的实例），这也是构造函数模式胜过工厂模式的地方
  • 构造函数当函数使用

      // 全局调用
      Person('kevin', 23);
      console.log(window.sayName);   // kevin
      // 使用call() 或 apply() 在另一个对象的作用域执行
      var o = {};
      Person.call(o, 'kevin', 27);
      o.sayName();    // kevin
  

  缺点： 构造函数里的函数属性会在每一个实例里重新创建一遍，即使函数代码是完全相同的。

• 原型模式

  创建的每一个函数都会有一个prototype属性，它指向一个对象，包含此构造函数的所有实例共享的属性和方法。不必在构造函数中定义对象

      function Person(){
      }
      Person.prototype.name = 'kevin';
      Person.prototype.age = 23;
      Person.prototype.sayName = function(){
          console.log(this.name);
      }
      var per1 = new Person();
      console.log(per1.name);  // kevin  来自原型
      per1.name = 'liyang';
      console.log(per1.name);  // liyang  来自实例
      // hasOwnProperty() 判断属性是否在实例中  
      per1.hasOwnProperty('name');   // true
      delete per1.name;
      console.log(per1.name);  //  kevin  来自原型
      per1.hasOwnProperty('name');   // false
  

• 组合模式(组合构造函数和原型模式)

        function Person(name, age){
            Person.prototype.name = name;
            Person.prototype.age = age;
        }
        Person.prototype.sayName = function(){
            console.log(this.name);
        }
        var per1 = new Person('kevin', 23);
  

对象的继承

• 原型继承（原型链）

    // 父类
    function Animal(name){
        this.name = name;
    }
    Animal.prototype.howling = function(){
        console.log('my name is ' + this.name);
    }
    // 子类
    function Wolf(){
    }
    // 此时Wolf的实例都会有animal所有的的属性和方法
    Wolf.prototype = new Animal('wolf');
    var wolf1 = new Wolf();
  

  缺点：
  + 实例中继承到的属性和方法都是公用的，一经修改，所有的实例都会有所体现。
  + 实例中继承到的实例和属性都是相同的，不能在实例化时，自定义父类中的属性和方法。

• 借用构造函数继承

    // 父类
    function Animal(name){
        this.name = name;
        this.howling = function(){
            console.log('my name is ' + this.name);
        }
    }
    // 子类
    // 此时Wolf的实例都会有单独一份、继承自父类中的属性和方法。
    function Wolf(name){
        Animal.call(this, name);
    }
    Wolf.prototype = new Animal('wolf');
    var wolf1 = new Wolf();
  

  缺点： 缺点和构造模式创建对象相同： 实例中的属性方法都是单独一份，即使函数代码是完全相同的，也不能复用，浪费内存。

• 组合模式

    // 父类
    function Animal(name){
        this.name = name;
    }
    Animal.howling = function(){
        console.log('my name is ' + this.name);
    }
    // 子类
    // 使用构造函数继承，
    // 优点：这样可以在实例对象时自定义父类中的属性。
    function Wolf(name){
        Animal.call(this, name);
    }
    // 使用原型链继承父类中原型的方法
    // 优点：可以复用相同的函数。
    Wolf.prototype = new Animal();
    var wolf1 = new Wolf(‘little wolf’);