JavaScript面向对象编程指南(五) 原型

第5章 原型

5.1 原型属性

        function f(a,b){
            return a*b;
        };
        // length  属性
        f.length;  //2
        // constructor 构造属性
        f.constructor; // function Function() { [native code] }
        // prototype 属性 初始值是空对象
        typeof f.prototype; //"object"

5.1.1 利用原型添加方法和属性

        function f1(name,color){
          // 使用this添加属性
           this.name=name;
           this.color=color;
           this.whatAreYou=function(){
            return 'I am a'+this.color+''+this.name;
           };
        }
        // 使用prototype属性添加属性和方法
        f1.prototype.price=100;
        f1.prototype.rating=3;
        f1.prototype.getInfo=function (){
          return 'Rating: '+this.rating+',price: '+this.price;
        };

5.1.2 使用原型的属性和方法

        function f1(name,color){
          // 使用this添加属性
           this.name=name;
           this.color=color;
           this.whatAreYou=function(){
            return 'I am a'+this.color+''+this.name;
           };
        }
        // 使用prototype属性添加属性和方法
        f1.prototype.price=100;
        f1.prototype.rating=3;
        f1.prototype.getInfo=function (){
          return 'Rating: '+this.rating+',price: '+this.price;
        };
       var f2=new f1('webcam','black');
       f2.color; // "black"
       f2.getInfo(); //"Rating: 3,price: 100"
       // 修改prototype属性，由同一构造器创建的所有对象的prototype属性也都会同时发生改变（会影响在修改之前已经创建的对象）
       f1.prototype.get=function(what){
        return this[what];
       }
       f2.get('price');  // 100

5.1.4 利用自身属性重写原型属性

对象自身属性的优先级高于原型属性

       function F1(name){
        this.name=name;
       };
       F1.prototype.name='Alen';
       var f2=new F1('XiaoMing');
       f2.name;  // "XiaoMing"  不是 Alen
       // 使用hasOwnProperty()判断一个属性是自身属性还是原型属性
       f2.hasOwnProperty('name');  //true
       //删除自身属性后，原型属性才会显示
       delete f2.name; // true
        f2.name; // "Alen"

5.1.5 isPrototypeOf()方法

isPrototypeOf()：当前对象是否为另一个对象的原型

        var person={
            like:'eat',
            age:12,
            sex:'boy'
        };
        function F1(name){
             this.name=name;
        }
        F1.prototype=person;
        var f2=new F1('Alen');
        // 判断person是否为f2的原型
       person.isPrototypeOf(f2);  //true
       //使用getPrototypeOf()获取原型
       Object.getPrototypeOf(f2)===person; //true

5.1.6 神秘的__proto__链接

5.2 扩展内建对象

 内建对象的构造器函数可以通过其原型来进行扩展。

    <script type="text/javascript">
      // 示例1：扩展Array的内建函数，用来查询数组中是否存在某个特定的值
      Array.prototype.inArray=function(needle){
        for (var i = 0; i < this.length; i++) {
            if(this[i]===needle){
               return true;
            }else{
                return false;
            }
        };
      };
      var colors=['red','black','blue'];
      colors.inArray('red');  //true
      colors.inArray('green'); //false
    //示例2：反转字符串
    // 先利用split()将目标字符串转换成数组，然后调用该数组的reverse()方法产生一个反向数组。
       // 最后通过join()方法将结果数组转换为字符串
    String.prototype.reverse=function (){
        return Array.prototype.reverse.apply(this.split('')).join('');
    };
    "bums".reverse(); //smub
    </script>

5.2.1 关于内建对象的讨论

 如果想通过原型为某个对象添加一个新属性，务必检查一下该属性是否已经存在。

5.2.2 原型陷阱

 注意： 1> 当对原型对象执行完全替换时，可能会触发原型链中某种异常

            2> prototype.constructor 属性不可靠

<script type="text/javascript">
        function Dog(){
            this.tail=true;
        };
        var f1=new Dog();
        var f2=new Dog();
        // 仍可以为Dog()的原型添加属性，添加之前已经存在的对象也可访问新属性
        Dog.prototype.say=function(){
            return 'worf';
        };
        // f1、f2可以访问新方法
        f1.say();  //"worf"
        f2.say(); //"worf"
        // 检查对象的构造器
        f1.constructor === Dog; // true  正常
        f2.constructor === Dog;// true  正常
        Dog.prototype.constructor === Dog; // true

        // 用自定义新对象完全覆盖掉原有的原型对象
        Dog.prototype={
            paws:4,
            hair:true
        };
        // 这样原有对象不能访问新属性,但通过__proto__与原有的原型保持联系
        f1.paws; //undefined
        f1.say();  //"worf"
        typeof f1.__proto__.say; // "function"
       // 之后创建的对象室友被更新后的prototype对象
       var f3=new Dog();
       f3.say(); // f3.say is not a function
       f3.tail; // true
       f3.paws; // 4
       // __proto__指向新的原型对象
       f3.__proto__.hair; //true

       // 新对象的constructor属性不在保持正确
       f3.constructor;// function Object() { [native code] }
                      // 本应该指向Dog(),现在指向Object
       f1.constructor; //function Dog(){this.tail=true;}  仍为Dog() 不变
       Dog.prototype.constructor; // function Object() { [native code] }
       //重新设置constructor属性 解决
       Dog.prototype.constructor=Dog;
       new Dog().constructor === Dog; // true
    </script>