1.prototype（原型）

1.prototype（原型）
      在JavaScript中，我们创建的每一个函数都有一个prototype（原型）属性，这个属性是一个对象，它的用途是保存某些可以被特定类型的所有实例所共享的属性或者方法。也就是说，当我们给某个函数Person的prototype增加属性或方法时，以Person为构造函数生成的所有实例都能访问到该属性或方法：
1.<script type="text/javascript">  

2.    //定义Person方法并创建两个Person实例  

3.    function Person(){}  

4.    var person1 = new Person();  

5.    var person2 = new Person();  

6. 

7.    //为Person的原型增加name属性和sayName方法 

  8.    //即使在实例的创建之后定义，但对实例也是立即可见的  

9.    Person.prototype.name = "Peter";  

10.    Person.prototype.sayName = function(){return this.name;};  

11.      

12.    //所有实例共享原型上的属性或者方法  

13.    alert(person1.name);        //Peter  

14.    alert(person2.name);        //Peter  

15.    alert(person1.sayName());   //Peter  

16.    alert(person2.sayName());   //Peter  

17.      

18.    //当实例中有同名的变量或者方法时，prototype的属性或者方法则被隐藏了（并非覆盖）  

19.    person1.name="Billy";  

20.    alert(person1.name);        //Billy  

21.    delete person1.name;  

22.    alert(person1.name);        //Perter  

23.      

24.    //使用hasOwnProperty()可以判断某个属性是否为自有属性  

25.    alert(person1.hasOwnProperty("name"));//false  

26.    person1.name="Jack";  

27.    alert(person1.hasOwnProperty("name"));//false  

28.</script> 
2.原型、构造函数和实例之间的关系
当我们定义一个函数的时候，它的默认的prototype对象便随之产生，这个prototype对象有一个construtor属性指向该函数，而使用该函数创建的所有实例内部都含有一个指针__proto__指向prototype对象（IE8中不能访问该指针）：
1.<script type="text/javascript">  

2.    function Person(){}  

3.    alert(Person.prototype);                    //[object Object]  

4.      

5.    //prototype的constructor属性指向Person  

6.    alert(Person.prototype.constructor);        //function Person(){}  

7.    alert(Person.prototype.constructor == Person);//true  

8.      

9.    //每个实例存在一个__proto__指针指向Person.prototype  

10.    //IE中不能访问  

11.    var person = new Person();  

12.    alert(person.__proto__);                    //[object Object]  

13.    alert(person.__proto__==Person.prototype);  //true（IE为false）  

14.</script> 3.原型链与继承
一个prototype是一个对象，因此，它必然有一个__proto__指针指向构造函数的prototype对象，同样道理，这个prototype对象又有一个__proto__指针指向构造函数的prototype对象，这样一环接一环直到Object.prototype，这就组成了一条原型链。当我们调用某个实例的属性或者方法的时候，首先从该实例寻找该变量或者方法，若找到则返回；否则寻找__proto__所指向的prototype对象，若还是没找到则继续寻找其__proto__指向的对象，直到找到或者到达原型链的末尾为止。我们可以通过这种查找方式实现继承。
1.function SuperType(name)  

2.{  

3.        this.name = name;  

4.}  

5.                   

6.SuperType.prototype.sayName = function(){ 

  7.        alert(this.name);  

8.};  

9.                   

10.function SubType(name, age)  

11.{    

12.        SuperType.call(this, name);  

13.        this.age = age;  

14.}  

15. 

16.    SubType.prototype = new SuperType();  

17.                   

18.SubType.prototype.sayAge = function()  

19.{  

20.        alert(this.age);  

21.};  

转载于:https://www.cnblogs.com/qiuwenjuan/p/3308098.html