javascript 原型实例

1. function SuperType(){}  
2.         
3.  SuperType.prototype.name = 'Sam';//在SuperType.prototype指向的对象上增加了name属性  
4.       
5.  //在SuperType.prototype指向的对象上增加了sayName方法  
6.  SuperType.prototype.sayName = function() {  
7.           document.write(this.name);  
8.  };  
9.  SuperType.prototype.setName = function(name) {  
10.           SuperType.prototype.name = name;  
11.  };  
12.       
13.  var instance1 = new SuperType();  
14.  var instance2 = new SuperType();  
15.       
16.  instance1.sayName();//Sam  
17.  instance2.sayName();//Sam  
18.       
19.  instance1.setName('Luce');  
20.        
21.  instance1.sayName();//Luce  
22.  instance2.sayName();//Luce 
    

 

 

      当实例instance1调用setName()函数更改了SuperType.prototype.name的值 后，instance2.sayName()也会输出Luce，说明SuperType.prototype指向的对象的确是“包含了可以由特定类型(这 里是SuperType)的所有实例所共享的属性和方法”，所以由此可以得出结论：

      SuperType.prototype指向的就是SuperType的原型对象，也即是函数的prototype属性指向了函数的原型对象。

 

 

Js代码  

1. function b(){};  
2. b.prototype.name='name1';  
3. b.prototype.sayName = function(){  
4.     console.log(this.name);  
5. };  
6. b.prototype.setName = function(p){  
7.     this.name = p;  
8. };  
9.   
10.    var a = new b();  
11. var c  = new b();  
12. a.sayName();  
13. c.sayName();  
14. a.setName('wen');  
15. a.sayName();  
16. c.sayName();  

 

  结果是：

 

 

 

 写道

 

name1
name1
wen
name1

 
你看你写的和我写的一不一样？你在方法sayName()和setName()里面引用的是this.name，在这里this指 向的是a和b对象，所以this.name访问的就是a.name或者b.name。就是说你这里this.name访问的是实例上的name属性，而不 是prototype所指向的原型对象上的name属性。 Javascript有个特点，就是当实例调用某个属性的时候，它会先在实例中找，如果找到就返回，否则继续在原型对象上找，找到再放回。在这里，当你访 问this.name的时候，由于没有在实例（a和b）中定义name属性，所以它就继续在原型对象上找，而原型对象上定义了name，所以第一次调用 a.sayName(); c.sayName(); 就会返回原型对象上定义的name属性，所以就返回了name1。而当你调用 a.setName('wen'); 的时候，this.name被换成了a.name,你实际上是在a对象上定义了name属性，而不是在原型对象上，所以该属性就不会是共享的，只有a所 有，所以a.sayName()就会返回wen（因为实例中有name，就不再搜索原型对象了）。而最后调用c.sayName();因为c中没有 name属性，所以它就到原型对象上找，所以就输出了原型对象上的name。