05月08, 2013

【JavaScript高级程序设计】对象的创建与继承

关于JS面向对象的部分中,关于对象的创建和继承的各种方法,以及这些方法之间的区别和适用场景是经常被问到的。

首先,关于对象的创建。

1.最简单的方法,大括号创建,var o = {};或者是用对象字面量方法,var 0 = {name:"jack",age = 10}; 问题:当使用相同接口创建很多对象时,会产生大量重复的代码。

2.工厂模式方法:将创建对象的细节封装起来,这样可以解决创建多个相似对象的问题。

function createA(){ 
    var o = new Object();
    o.name = "jack"; 
     o.age = 10;      
    return o;  
}      
var A = createA();

问题:带来了对象识别问题,不能知道一个对象的类型。也就是说用instansOf()方法无法确定对象的类型。 注意:不能用new来调用创建对象的函数,并且在函数的内部要返回那个Object对象。

3.构造函数方法

function Person(name,age){          
    this.name = name;          
    this.age = age;          
    this.sayName = function (){              
        alert(this.name);          
    }      
}          
var person = new Person("jack",10);

通过检查实例的constructor属性,或者使用instanceof()方法可以确定对象的类型。 问题:每个方法都要在每个实例上创建;创建多个完成相同任务的Function实例是没必要的。 如果把这样的Funtion从构造函数中移除来,则函数会变成为全局环境中的成员,破坏了封装性。

4.原型模式 原型:是指向一个对象的,这个对象包含由所有实例共享的方法和属性。

function Person(){   }      
Person.prototype.name = "jack";      
Person.prototype.age = 10;      
Person.prototype.sayName = function (){          
    alert(this.name);      
}  
var wang = new Person();

注意:所有的实例保存的仅是指向对象原型的指针。所有实例共享原型的属性和方法。实例可以重写属性,覆盖原型对象中的相同属性,但是并不改变原型中的这个属性。 可以使用hasOwnPropertyp()来判断,当属性存在于对象中时返回true。if (wang.hasOwnProperty("name")) {alert(true);} 比如:

var wang = new Person();
    console.log(wang.age); //10
    wang.age = 20;
    console.log(wang.age); //20
    var li = new Person();
    console.log(li.age);   //10

问题:省略了为构造函数传参,所有实例在默认情况下都取得相同的属性值。尤其当属性为引用值时,会相互干扰。 5.组合构造函数和原型模式 将实例属性在构造函数中定义。 所有实例共享的属性和方法在原型中定义。

function Person(name,age){          
    this.name = name;          
    this.age = age;      
}          
Person.prototype = {          
    constructor: Person,          
    sayName: function(){              
        alert(this.name);          
    }      
};      
var wang = new Person("jack",10);     
wang.sayName();      
var li = new Person("nike", 10);      
li.sayName();

说完了对象的创建,再说一下对象的继承。 1.原型链继承 每一个构造函数中都有一个指针prototype,这个指针指向原型对象,而原型对象中又都有一个属性constructor,指向这个构造函数。同时每个实例中都有一个指向原型对象的指针。

 function SuperType(){      } 
  SuperType.prototype.getSuperValue = function(){      };  
 function subType(){      }  
 subType.prototype = new SuperType();//重写了subType的原型,此时constructor指向superType的原型对象  
 subType.prototype.getSubValue = function(){      };

注意:新加的子类原型方法,应该在继承了父亲原型之后。 使用原型链方法继承时,不能用对象字面量来创建原型方法,这样会重写子类原型,使得constructor指向Object。 问题: a.由于包含引用型的原型属性会被所有实例共享。所以,如果父类的构造函数中有一个引用型数组,则对父类的每一个实例间无影响。 但是子类的原型是父类的一个实例。子类的所有实例都会共享这个属性 b.创建子类实例时无法向父类的构造函数传参。

2.借用构造函数

function superType(name){      
    this.name = name;      
    this.colors = ["black","green"];  
}  
function subType(){      
    superType.call(this,"jack");      
    this.age = 10;  
}

在调用subType()时,会借调superType()的所有代码,子类的实例创建实例自己的colors副本。 问题:方法都在构造函数中定义,没有了函数的复用。 同时,在父类原型中定义的方法和属性,子类无法继承到。

3.组合继承 通过原型链来实现对原型属性和方法的继承;借用构造函数来实现对实例属性的继承。 问题:无论在什么情况下,都会调用2次父类构造函数。

function superType(name){
            this.name = name;
        }
        superType.prototype.getSuperValue = function(){

        };
        function subType(name,age){
            superType.call(this,name);
            this.age = age;
        }
        subType.prototype = new superType();
        subType.prototype.constructor = subType;
        subType.prototype.sayAge = function(){

        }

4.原型式继承 基于现有的对象,再创建一个新对象。 适用场景:只想让一个对象与另一个对象保持相似的情况下。

function object(o){      
    function F(){} //创建临时性的构造函数      
    F.prototype = o;//将传入的对象作为这个构造函数的原型      
    return new F();//返回这个临时类型的新实例  
}

object()对传入的对象进行了浅复制。 person1 = object(Person); person2 = object(Person); 相当于创建了2个person的副本。

5.寄生式继承 与创建对象的工厂模式类似

function another(o){
            var clone = object(o);
            clone.sayHi = function(){

            };
            return clone;
        }

问题:无法做到函数的复用。

6.寄生组合式 这是最有效的一种继承方式。只调用了一次superType()构造函数,同时还没有改变原型链。 首先创建如下函数:

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

然后使用时,与组合继承类似,但是不同的是将subType.prototype = new superType();subType.prototype.constructor = subType;这两句代码换成,ip(subType,superType); 最后,理解对象的创建和继承,关键是理解构造函数,原型对象以及实例之间的关系。这个稍后上图。

版权声明:本文为博主原创文章,未经博主允许不得转载。

本文链接:https://imjiaolong.cn/post/17.html

-- EOF --

Comments

评论加载中...

注:如果长时间无法加载,请针对 disq.us | disquscdn.com | disqus.com 启用代理。