还是原型的问题

Question

function A(){}
A.prototype.z=8;
function B(){B.prototype=new A();/*2*/}
B.prototype.z=0;//1var createInstance = function(source){
    var p = {}
    var args = Array.prototype.slice.call(arguments,1);
    alert(source.prototype.constructor);//1
    p.__proto__ = source.prototype;//1
    source.apply(p,args);
    alert(source.prototype.constructor);//2
    return p;
}var a = createInstance(B);
alert(a.z);//undefined 为什么不是 8 ？

Answer 1

1. 我觉得应该是0，我的FF版本是3.5.1
2. 不是8的原因是你把对象p对应的__proto__换成了构造函数B的原型(prototype)，而不是构造函数A的原型

Answer 2

apply不会应用对象prototype新增的方法或属性.
你把function B()改为function B(){A.call(this);} 使用call来继承A,就可以正常输出8了

Answer 3

function A(){} 
A.prototype.z=8;
b=new A()
alert(b.z)//8
b会 继承原型的属性
-----
function A(){} 
A.prototype.z=8; 
function B(){B.prototype=new A();/*2*/} 
B.prototype.z=0;//1 var createInstance = function(source){ 
    var p = {} 
    var args = Array.prototype.slice.call(arguments,1); 
    alert(source.prototype.constructor);//1 
    p.__proto__ = source.prototype;//1 
    source.apply(p,args); 
    alert(source.prototype.constructor);//2 
    return p; 
} var a = createInstance(B); 
A的构造函数中没有z属性,但是A的原型属性有z属性，以 A 为原型的 B 的实例 a  ,会继承A的原型属性吗？还是只继承它的构造属性？

Answer 4

矛盾，困惑啊，请比较下面的三个：
function A() 
{} function B() 
{ 
B.prototype=new A(); 
} B.prototype.z=0; 
var b=new B(); 
alert(b.constructor); 
B.prototype.z=10; 
alert(b.z); //0 
b=new B(); 
//B.prototype.z=10; 
alert(b.constructor); 
alert(b.z); //10 ,这又如何解释？--------
function A() 
{} function B() 
{ 
B.prototype=new A(); 
} B.prototype.z=0; 
var b=new B(); 
alert(b.constructor); 
//B.prototype.z=10; 
alert(b.z); //0 
b=new B(); 
B.prototype.z=10; 
alert(b.constructor); 
alert(b.z); //undefined ,这又如何解释？------
js 比静态对象语言更神奇的是，我们可以随时给原型对象动态添加新的属性和方法，从而动态地扩 
展基类的功能特性。这在静态对象语言中是很难想象的。我们来看下面的代码： 
function Person(name) 
{ 
this.name = name; 
}; 
Person.prototype.SayHello = function() //建立对象前定义的方法 
{ 
alert("Hello, I'm " + this.name); 
}; 
var BillGates = new Person("Bill Gates"); //建立对象 
BillGates.SayHello(); 
Person.prototype.Retire = function() //建立对象后再动态扩展原型的方法 
{ 
alert("Poor " + this.name + ", bye bye!"); 
}; 
24 
BillGates.Retire(); //动态扩展的方法即可被先前建立的对象立即调用 
----李占 < <悟透 JavaScript>>

Answer 5

你创建对象不是使用new,而是使用apply来复制一个对象.
用new的话，不管是原属性或方法还是prototype加的属性或方法都会应用到. apply只会应用原属性.<script type="text/javascript">
function A(){}
b=new A();
A.prototype.z=8;
alert(b.z) //output 8function B(){A.apply(this);}b=new B();
alert(b.z); //output undefined
</script>

Answer 6

如楼上所说，我试了，原型的附加属性 还是显示不出来：
function A(){} 
b=new A(); 
A.prototype.z=8; 
alert(b.z) //output 8 function B(){A.call(this);} b=new B(); 
alert(b.z); //output undefined 
</script>

Answer 7

function A() 
{} function B() 
{ 
B.prototype=new A(); 
} B.prototype.z=0; 
var b=new B(); 
alert(b.constructor);
B.prototype.z=10; 
alert(b.z); 
b=new B(); //这里是再次产生一个新对象 B ，还是对上次产生的对象 B 的引用？
alert(b.constructor);
alert(b.z);//10

Answer 8

还是迷糊
function A() 
{} function B() 
{ 
B.prototype=new A(); 
} B.prototype.z=0; 
var b=new B(); 
alert(b.constructor);
B.prototype.z=10; 
alert(b.z); //0
b=new B(); 
alert(b.constructor);
alert(b.z); //10

Answer 9

回到你开始的问题，你把重点放在你的createInstance方法上，因为你是由他来创建对象的.var createInstance = function(source){ 
    var p = {} 
    var args = Array.prototype.slice.call(arguments,1); 
    alert(source.prototype.constructor);//1 
    p.__proto__ = source.prototype;//1 
    source.apply(p,args); 
    alert(source.prototype.constructor);//2 
    return p; 
} 里面有一个对prototype集合复制的方法,就是__proto__. 
但是这个ie不支持.所以在IE的情况下，目标对象的prototype下的方法或属性会全部丢失,也就是你找不到z属性的原因.FF下完全正常.其实你可以对方法做一个改进,因为上面说了apply会放弃prototype下的属性或方法.
var createInstance = function(source){ 
    var p = {} 
    var args = Array.prototype.slice.call(arguments,1); 
    if(!document.all){
      p.__proto__ = source.prototype;//1 
    }
    else{ //IE
      for(var x in source.prototype){
         p[t]=source.prototype[t]
      }
    }
    source.apply(p,args); 
    return p; 
} 你试试吧.我都被你的问题弄晕了...

Answer 10

如果你采用你的createInstance方法来创建对象，实际上是将源对象复制了一份.
如果你采用new 方法来创建对象，实际上是对源对象的引用.