构造函数和原型

Question

有人可以解释一下吗？

function Foo() {
    this.x = 1;
    this.y = 2;
}

function FooProto() {
    this.arrow = 1;
    this.bow = 1;
}

document.writeln(Foo.prototype); // [object Object] 
document.writeln(Foo.prototype.constructor); // function Foo() { x =1; y=2; }

我的理解是:Foo.prototype是一个Object,其构造函数属性是Function Foo.Foo.[[Prototype]]是Function.Prototype

obj = new Foo;
document.writeln(obj.constructor); // function Foo() { x =1; y=2; }
document.writeln(obj.constructor.prototype); // [object Object]

Foo.prototype = FooProto;

document.writeln(Foo.prototype); // function FooProto() { arrow = 1; bow = 2; }
document.writeln(Foo.prototype.constructor); // function Function() { [native code] }

问题1:如何使用[[Prototype]]进行查找.如果有人能向我解释,我将不胜感激.

document.writeln(obj.constructor); // function Foo() { x =1; y=2; } .. no change
document.writeln(obj.constructor.prototype); // function FooProto() { arrow = 1; bow = 2; }

anotherObj = new Foo;
document.writeln(anotherObj.constructor); // function Function() { [native code] }
document.writeln(anotherObj.constructor.prototype); // function Empty() {}

问题2:与问题1相同的问题.Javascript解释器是如何执行查找的？

Answer 1

在解释基于原型的代码时,使用它Object.create来解释内容要简单得多.Object.create是一个接收原型对象的函数,并创建一个新的实例对象,其原型对象为[[prototype]]

在对象中查找属性时,工作方式如下:

每个对象都有自己的,不可变的[[prototype]]属性.这个属性是秘密和隐藏的,除非你在Firefox中,你可以通过它获得它__proto__.

在读取属性时,我们首先在对象本身中搜索它,如果我们在那里找不到它,我们递归搜索对象的[[prototype]].

在编写属性时,我们总是编写一个自己的属性(我们永远不会改变[[prototype]],即使它也具有我们正在设置的属性).

proto = {a:1};
child1 = Object.create(proto);
child2 = Object.create(proto);

child1.a = 2;

console.log(proto.a);  //1
console.log(child1.a); //2
console.log(child2.a); //1

创建功能时

每当我们在Javascript中创建一个函数对象时,它都会附带一个prototype已经填充的属性.这prototype是一个对象(继承自Object.prototype)并且将constructor属性设置为相应的函数.

使用函数构造函数实例化对象时(new Foo)

使用函数prototype[[prototype]] 创建一个新对象,并在该对象上运行该函数以初始化它.

1. 我真的不想解释第一种情况发生了什么,因为这 Foo.prototype = FooProto;部分并没有真正意义,可能不是你想做的事情(记住原型应该是对象,而不是函数)

2. 至于第二种情况,更改prototype构造函数的属性只会影响将来的实例(anotherObj).已创建对象的[[prototype]]属性是秘密且不可变的,因此您无法更改它们.

   • 请注意,如果要动态更改原型和现有对象(猴子修补),可以通过在现有原型对象中编写和覆盖值而不是用新的替换它来实现.