Warning: file_get_contents(/data/phpspider/zhask/data//catemap/9/javascript/467.json): failed to open stream: No such file or directory in /data/phpspider/zhask/libs/function.php on line 167

Warning: Invalid argument supplied for foreach() in /data/phpspider/zhask/libs/tag.function.php on line 1116

Notice: Undefined index: in /data/phpspider/zhask/libs/function.php on line 180

Warning: array_chunk() expects parameter 1 to be array, null given in /data/phpspider/zhask/libs/function.php on line 181
Javascript ';超级';与'相比确定;这个';? 这是由执行上下文决定的_Javascript_Prototype_Super - Fatal编程技术网

Javascript ';超级';与'相比确定;这个';? 这是由执行上下文决定的

Javascript ';超级';与'相比确定;这个';? 这是由执行上下文决定的,javascript,prototype,super,Javascript,Prototype,Super,我习惯了JavaScript中这个的特性。在下面的示例中,此由执行上下文确定。即使在x上定义了getProtoProviaThis函数,但是this的值取决于函数的调用方式: const xProto={ 原型:“x”, }; 常数x={ GetProtoProviaThis(){ 返回此.protoProp; }, } setPrototypeOf(x,xProto); 常数yProto={ 原型:“y”, }; 常数y={ GetProtoProviaThis:x.GetProtoProv

我习惯了JavaScript中
这个
的特性。在下面的示例中,
由执行上下文确定。即使在
x
上定义了
getProtoProviaThis
函数,但是
this
的值取决于函数的调用方式:

const xProto={
原型:“x”,
};
常数x={
GetProtoProviaThis(){
返回此.protoProp;
},
}
setPrototypeOf(x,xProto);
常数yProto={
原型:“y”,
};
常数y={
GetProtoProviaThis:x.GetProtoProviaThis,
}
setPrototypeOf(y,yProto);
console.log(x.getProtoProviaThis());//输出:x
console.log(y.getProtoProviaThis());//输出:y
当创建并保留
x
对象时,可能会以某种方式存储该绑定,即使将函数分配给
y

是的,事实就是这样。
getProtoProviaSuper
方法基本上关闭了它在中定义的对象。这存储在函数本身的内部[[HomeObject]]槽中,这就是为什么如果将方法分配给不同的对象,或者更重要的是,在不同的对象上继承它,则会保留它1的原因。对于对象文本中的方法定义,它是由文本创建的对象;对于
class
es中的方法定义,它是该类的
.prototype
对象

1:要了解为什么它需要是静态引用,而不是依赖于调用的对象,如
Object.getPrototypeOf(this)
,请参阅

如果它保留了原始对象,那么可能会导致内存泄漏,因为原始对象无法被垃圾收集

不,它不会造成比其他闭包更多的内存泄漏。当然,该方法可以防止其主对象被垃圾收集,但鉴于主对象是一个原型对象(至少在正常使用中是这样),并且在通常调用该方法的对象的原型链中也引用了该原型对象,这不是问题

如果有人能用通俗易懂的语言解释这种行为,我将不胜感激。
super
如何确定其值

它获取其绑定的主对象的原型,该对象是在其中定义方法的对象。但是请注意,访问
super
上的属性并不会返回对该对象属性的普通引用,而是一个特殊引用,当调用(方法)时,它会将当前范围的
this
值作为方法调用的
this
参数,而不是原型对象。总之,

const x = {
  method() {
    super.something(a, b);
  }
}
去糖衣

const x = {
  method() {
    Object.getPrototypeOf(x).something.call(this, a, b);
  }
}
class X {
  method() {
    Object.getPrototypeOf(X.prototype).something.call(this, a, b);
  }
}

去糖衣

const x = {
  method() {
    Object.getPrototypeOf(x).something.call(this, a, b);
  }
}
class X {
  method() {
    Object.getPrototypeOf(X.prototype).something.call(this, a, b);
  }
}

不要使用
\uuuu proto\uuuu
,我知道这是谢谢你的。这样演示更容易。问题不在于proto@limido重写以避免使用
\uuuuuuuuuuuu
协议。我不确定这是否有助于解决这个问题,但希望现在它不会让人分心。我开始认为这可能是一个Chromium bug,但我在Firefox和Safari中进行了双重检查,得到了相同的行为,所以我想这符合标准。我只是不理解标准。从您现在添加的链接中:“由于super在[[HomeObject]].[Prototype]]中查找父方法,这意味着它搜索sayHiMixin.[Prototype]],而不是用户。[[Prototype].”另请参见“谢谢”。到目前为止,我读过的所有文档都使用了一些模糊的手势语言,表示
super
指向对象的原型,但显然有一个警告。。。它转到最初定义函数的对象的原型。另外,关于此
的额外部分也是一个有用的标注。有趣的是,
Object.setPrototypeOf
将更新
[[HomeObject]]
引用。我想这就是函数如此缓慢的部分原因。@jdbstillmembersmonica不,它不会更新函数的[[HomeObject]],但鉴于
super
查找[[HomeObject]]的原型,您当然可以通过更改[[HomeObject]]的原型来更改您将获得的内容@jdbstillmembersmonica最初它甚至……是对铬如何实际存储[[HomeObject]]的一个迷人的深入研究。。。它是函数上的隐藏符号属性。只要对源代码稍加修改,就可以将其公开。相当整洁。