每个函数都有一个prototype属性,这个属性本身又是一个对象,它的用途是包含可以由所有实例共享的属性和方法。
function People(name) {
        this.name = name;
        this.a = "dd";
    }
var people1 = new People("熊俊");
var people2 = new People("精华");
document.write(people1.name);
document.write(people2.name);
document.write(people1.a);
document.write(people2.a);上面的代码,两个实例不也是共享了a属性吗?为什么JavaSciript中要用prototype这个东西?

解决方案 »

  1.   

    没有共享啊  每个对象都有一个a  只是值都是dd而已
    就是每个对象都有一个值为dd的a  但未共享
    你将people1的a重新赋值后people2的a不会跟着变的
      

  2.   

    function People(name) {
            this.name = name;
            this.a = "dd";
    }
    var people1 = new People("熊俊");
    var people2 = new People("精华");
    people1.a="c";
    document.write(people1.a);
    document.write(people2.a);
      

  3.   

    简单回答一下楼主一下这个:为什么JavaSciript中要用prototype这个东西? 
    不知道楼主知不知道什么叫原型继承:
    举个简单例子:
    function f1(){ 
       this.method1=function(){
           return 'method1'
       }
    }
    f1.prototype.method2=function(){return 'method2'}
    var obj=new f1()
    我理解的js,当js引擎读到new f1()时,其实是先new Object,即实例出了一个Object类的对象,然后这个空对象(其实不是空对象,它里面有一个constructor属性和String属性)原型继承了f1.prototype的一组对象,也可以说是这个空对象深拷贝了f1.prototype所指向的对象,如果你不理解啥叫深拷贝,我举个例子比如说m,n是两个对象,
      var m=new Object();
      m.x=10
      m.method1=function(){
        return 'ok'
      }
    如果说让n深拷贝m, 不是说让n=m, 这叫浅拷贝,浅拷贝的特点是m把对象在内存堆中的地址拷贝给n,也就是说m和n指向的是同样的对象,当m.x=100时,n.x也变为100,这并不是我希望的,我希望的是n和m是两个对象。那如何深拷贝呢?
    方法如下:
    var m={};
    m.x=1;
    m.method=function (){return 123}
    var n={};
    for(shuxing in m){
       n[shuxing]=m[shuxing]
    }
    alert(n.x)
    alert(n.method)
    这时候改变m.x的时候,n.x不会同时发生改变,这就叫深拷贝。
    这里有一点必须要清楚:在js中,一个变量类型是由变量的值决定,比如说:
    var a=1
    它在内存的栈中存的就是a=1
    如果var a=function(){ alert('ok') }
    那么a在栈中存的是一个地址,这个地址指向的是堆中的function(){ alert('ok') },
    理解这个就应该明白上面m.method和n.method存的都是相同的地址,这个地址指向function (){return 123}回到本文正题:
    function f1(){ 
       this.method1=function(){
           return 'method1'
       }
    }
    f1.prototype.method2=function(){return 'method2'}
    每当我实例化一个f1时,this.method1这样的属性都要被创建一次存在堆中,创建10个对象,就要10个这样的function(){return 'abc'}函数实体,而method2这样的原型方法只是复制了10个指向它的地址,而存在堆中的function(){return 'method2'}实体函数始终就一个。
    这个哪个效率高,一目了然了吧,不知道这么说楼主能明白不
      

  4.   

    有几个地方说的不准确,纠正一下:
    第12行:"原型继承了f1.prototype的一组对象",应该是原型继承了f1.prototype的一组属性和方法;
    倒数第4行:"就要10个这样的function(){return 'abc'}函数实体"应该是function(){return 'method1'}"
      

  5.   

    js访问对象成员时(以a成员为例),过程是:
    1.在对象自身寻找成员a,若有,则访问该成员
    2.若对象自身没有a成员,在其构造函数原型链即prototype成员上寻找a成员,若有,则访问该成员
    3.若构造函数原型链上仍然没有该成员,则该成员为undefined
    经典示例:
    function test(){
    }
    test.prototype.a='a';
    var obj1=new test();
    var obj2=new test();
    alert(obj1.a+","+obj2.a);//弹出a,a,似乎obj1和obj2都已经有了a成员,但真是这样么?obj1.a='a';//似乎是无用的,因为obj1.a本就等于a
    test.prototype.a='a1';
    alert(obj1.a+","+obj2.a);//弹出a,a1,自己领会玄机
      

  6.   

    我觉得就是1个过程:
    1.在对象自身寻找成员a,若有,则访问该成员,没有就undefined
      

  7.   

    我觉得第二步不会出现这种情况,举个例子function f1(){};
    f1.prototype.x=10;
    var obj=new f1();
    f1.prototype.y=200;
    for(m in obj){
    alert(m);
    }在obj已经实例出的情况下,我增加了一个原形属性y,然后遍历obj, 可以显示出y属性,说明f1.prototype.y=200这条语句一执行,obj对象已经有了y属性,所以不会有“2.若对象自身没有a成员,在其构造函数原型链即prototype成员上寻找a成员,若有,则访问该成员” 这种情况发生。
      

  8.   

    你的说法建立在"for in 只会从对象自身寻找成员"上,你能保证是这样的么?你连我说的是什么都不清楚,就不要再说了
      

  9.   


    function f1(){};
    f1.prototype.x=10;
    var obj=new f1();
    f1.prototype.y=200;
    for(m in obj){
        if(obj.hasOwnPrototype(m)) {
          alert(m);
        }
    }
      

  10.   

    function f1(){};f1.prototype.x=10;var obj=new f1();f1.prototype.y=200;for(m in obj){    if(obj.hasOwnProperty(m)) {      alert(m);    }}
    9楼写错了,更正下,建议coglass看下这个,你理解的for in是不对的,for in 会遍历原型链的