Sprechen Sie kurz über die implizite Bindung davon in JavaScript_Grundkenntnisse

Schauen wir uns zunächst ein Beispiel an

function foo() {
  console.log( this.a );
}
var obj = {
  a: 2,
  foo: foo
};
obj.foo(); // 2

Dies weist auf obj hin, da die Aufrufstelle bei der Ausführung von foo (kann als Bereich beim Aufruf verstanden werden) über obj liegt. Beachten Sie, dass es zur Laufzeit erfolgt und nichts damit zu tun hat, wo es deklariert ist.

Call-Site und Call-Stack

Call-Site wird vorübergehend als Anrufdomäne verstanden, und Call-Stack ist der Call-Stack. Der folgende Code kann uns beim Verständnis helfen

function baz() {
  // call-stack is: `baz`
  // so, our call-site is in the global scope

  console.log( "baz" );
  bar(); // <-- call-site for `bar`
}

Rufen Sie bar() in baz() auf, sodass die aufrufende Domäne von bar baz ist. Zu diesem Zeitpunkt ist der Aufrufstapel von bar nur baz, und baz selbst ist im globalen Bereich verfügbar, sodass auch seine aufrufende Domäne betroffen ist der globale Geltungsbereich in der Domäne.

function bar() {
  // call-stack is: `baz` -> `bar`
  // so, our call-site is in `baz`
  console.log( "bar" );
  foo(); // <-- call-site for `foo`
}
function foo() {
  // call-stack is: `baz` -> `bar` -> `foo`
  // so, our call-site is in `bar`
  console.log( "foo" );
}
baz(); // <-- call-site for `baz`

Nachdem Sie es verstanden haben, schauen Sie sich noch einmal das Beispiel am Anfang an und es wird viel klarer. Tatsächlich verweist dies nur auf die Aufrufseite

Es gibt auch folgende Spielmöglichkeiten:

function foo() {
  console.log( this.a );
}
var obj2 = {
  a: 42,
  foo: foo
};
var obj1 = {
  a: 2,
  obj2: obj2
};
obj1.obj2.foo(); // 42
Implicitly Lost（隐式丢失）
function foo() {
  console.log( this.a );
}
var obj = {
  a: 2,
  foo: foo
};
var bar = obj.foo; // function reference/alias!
var a = "oops, global"; // `a` also property on global object
bar(); // "oops, global"

Obwohl sich bar auf foo in obj bezieht, entspricht es tatsächlich dem direkten Verweis auf foo, sodass es standardmäßig an das Global gebunden ist.

function foo() {
  console.log( this.a );
}
function doFoo(fn) {
  // `fn` is just another reference to `foo`
  fn(); // <-- call-site!
}
var obj = {
  a: 2,
  foo: foo
};
var a = "oops, global"; // `a` also property on global object
doFoo( obj.foo ); // "oops, global"