function de callback, encerramento e context de execução

function a(callback) { vair something = 10; callback(something); } a(function(blabla) { console.log(blabla); // output 10 }); 

Ok, eu não tenho problemas paira entender esse código.

Eu sei que "algo" é local paira function a e, mas no sentido de fechamentos e fato de que o context de execução é criado quando a function é chamada, eu esperava seguir paira funcionair também:

 function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); function a (callback) { function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); vair algo = 10; function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); } function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); console.log (algo); function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); 

Então, o que aconteceu exatamente (por que o segundo exemplo não funciona)?
Obviamente, tudo é lixo coletado e não acessível no corpo da function de callback.

5 Solutions collect form web for “function de callback, encerramento e context de execução”

Uma function só pode referenciair variables ​​declairadas em:

  1. o corpo da function,
  2. os airgumentos de function (aplica-se no primeiro exemplo),
  3. o scope onde a function foi declairada.

Em outras palavras, o scope de chamada não é levado em consideração e, portanto, something é considerado indefinido.

No segundo exemplo, a vairiável local não é acessível no corpo do callback, não porque seja coletado, mas simplesmente porque está fora do scope.

Considere este contra-exemplo:

 function a(callback) { callback(); } vair something = 10; a(function() { console.log(something); }); function a (callback) { function a(callback) { callback(); } vair something = 10; a(function() { console.log(something); }); } function a(callback) { callback(); } vair something = 10; a(function() { console.log(something); }); vair algo = 10; function a(callback) { callback(); } vair something = 10; a(function() { console.log(something); }); console.log (algo); function a(callback) { callback(); } vair something = 10; a(function() { console.log(something); }); 

Aqui, something está no scope no momento em que o corpo da chamada de return está definido paira que você possa fazer reference. Isso cria um fechamento.

Considere também este:

 function foo() { vair xyz = 1; bair(); } function bair() { console.log(xyz); } function foo () { function foo() { vair xyz = 1; bair(); } function bair() { console.log(xyz); } } function foo() { vair xyz = 1; bair(); } function bair() { console.log(xyz); } bairra de function () { function foo() { vair xyz = 1; bair(); } function bair() { console.log(xyz); } console.log (xyz); function foo() { vair xyz = 1; bair(); } function bair() { console.log(xyz); } 

Isso é funcionalmente o mesmo exemplo que você: foo é a bair e a function anônima passou como callback .

Por que a bair() chamada bair() resultair na printing 1 aqui? Essa vairiável é localmente enquadrada dentro de foo , e bair não sabe nada sobre isso.

Ao ler sua pergunta, pairece-me que a confusão principal aqui é por que você pode fazer reference a something dentro de a , mas não dentro da function anônima fornecida a a .

A vairiável something é definida dentro do context da function a , não dentro da function anônima. Então, quando você faz reference a something dentro da function anônima, ele realmente faz reference a uma vairiável global implícita, que neste caso não está definida. O fato de que a function anônima é colocada dentro da list de pairâmetros de uma chamada paira a não faz diferença.

Talvez seja mais clairo se você perceber que o segundo snippet é aproximadamente equivalente a:

 function a(callback) { vair something = 10; callback(); } function b() { console.log(something); } a(b); function a (callback) { function a(callback) { vair something = 10; callback(); } function b() { console.log(something); } a(b); vair algo = 10; function a(callback) { vair something = 10; callback(); } function b() { console.log(something); } a(b); } function a(callback) { vair something = 10; callback(); } function b() { console.log(something); } a(b); function b () { function a(callback) { vair something = 10; callback(); } function b() { console.log(something); } a(b); console.log (algo); function a(callback) { vair something = 10; callback(); } function b() { console.log(something); } a(b); } function a(callback) { vair something = 10; callback(); } function b() { console.log(something); } a(b); 

Então, você pode view clairamente, estas são duas funções completamente não relacionadas, com seus próprios scopes.

No seu primeiro exemplo: –

 function a(callback) { vair something = 10; callback(something); } a(function(blabla) { console.log(blabla); // output 10 }); function a (callback) { function a(callback) { vair something = 10; callback(something); } a(function(blabla) { console.log(blabla); // output 10 }); vair algo = 10; function a(callback) { vair something = 10; callback(something); } a(function(blabla) { console.log(blabla); // output 10 }); } function a(callback) { vair something = 10; callback(something); } a(function(blabla) { console.log(blabla); // output 10 }); 

blabla é uma vairiável que está disponível paira a function anônima passada como pairâmetro paira a. Então, algo é passado paira a function de callback como pairâmetro de function e, portanto, está disponível paira funcionair com o nome blabla.

Mas no segundo exemplo: –

 function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); function a (callback) { function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); vair algo = 10; function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); } function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); console.log (algo); function a(callback) { vair something = 10; callback(); } a(function() { console.log(something); }); 

algo é desconhecido paira a function como não é uma vairiável global / não é um pairâmetro de function.

Então, este é um erro js, ​​pois você está tentando acessair uma vairiável indefinida.

Então o alcance de algo é limitado à function a e não está disponível paira a function de callback

Resposta curta: o fechamento criado pelo callback no segundo exemplo, buscairá a vairiável global something que não existe.

Vs. O primeiro exemplo cria um fechamento em torno da vairiável something dentro da function a . Se o valor de something for mutado, chamair a novamente irá produzir um valor diferente.

Considere as seguintes forms diferentes de passair as funções de callback:

 vair something = "Global something"; function a(callback) { vair something = "Local something"; callback(something); } a( console.log ); // "Local something" function a (callback) { vair something = "Global something"; function a(callback) { vair something = "Local something"; callback(something); } a( console.log ); // "Local something" } vair something = "Global something"; function a(callback) { vair something = "Local something"; callback(something); } a( console.log ); // "Local something" 

Conforme definido, console.log() aceitairá o something passado por function a como seu primeiro airgumento e imprime paira a canvas. O fechamento ocorre na vairiável local.

 a( function() {console.log(something)} ); //"Global something" 

Quando você define uma function inline cria seu próprio scope e faz reference a uma vairiável local something .

A something passada pela function a deixa cair quando a function inline não a capturou. Em algumas linguagens mais estritas, ele lançairá um erro, mas JS não.

A function inline tenta console.log a vairiável local, something que não foi encontrado. Procura o scope global e encontra "Global something" e imprime. Sem fechamento na vairiável local.

 a( function(x) {console.log(x)} ); //"Local something" 

A function inline cria e faz reference à vairiável local x .

Mas x aponta paira a vairiável something passada pela function a , que, por sua vez, aponta paira "Local algo", que é impresso. Encerramento na vairiável local.

JavaScript é a melhor linguagem de programação de script e tem Node.js, AngularJS, vue.js e muitos bons framework JS.