Parlez brièvement de la liaison implicite de ceci dans les connaissances JavaScript_Basic

Regardons d'abord un exemple

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

Cela pointe vers obj, car le site d'appel lorsque foo est exécuté (peut être compris comme la portée lors de l'appel) est au-dessus de obj. Notez qu'il est au moment de l'exécution et n'a rien à voir avec l'endroit où il est déclaré.

site d'appel et pile d'appels

Call-site est temporairement compris comme le domaine d'appel, et call-stack est la pile d'appels. Le code suivant peut nous aider à comprendre

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

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

Appelez bar() dans baz(), donc le domaine appelant de bar est baz Pour le moment, la pile d'appels de bar n'est que baz et baz lui-même est exposé dans la portée globale, donc son domaine appelant affecte également. la portée mondiale dans le domaine.

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`

Après l'avoir compris, revenez à l'exemple du début et cela deviendra beaucoup plus clair. En fait, cela pointe simplement vers son site d'appel

Il existe également des façons de jouer comme suit :

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"

Bien que bar fasse référence à foo sur obj, cela équivaut en fait à référencer directement foo, il sera donc lié au global par défaut.

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"