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

WEB前端 34 2017-11-09 10:17

对象的属性

对象的属性分为两种: 数据属性(可直接定义)和访问器属性(必须通过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’);
    
文章评论