Javascript：如何在回调函数中访问局部变量？

这是范围的问题。代码可以访问在函数中声明的变量，其包含的函数（如果有的话），其包含的函数（如果有的话）等等，然后是全局变量。

在您的第一个示例中，readFileCallback是在form.on回调外部声明的，因此它无权访问form.on回调内部的内容。

在第二个例子中，该功能是里面的form.on回调，所以它可以访问它里面的东西。

请注意，在第二个示例中，理论上每次调用回调时都会创建一个新函数。很好，JavaScript引擎确实可以很快地创建函数（即使创建了单独的函数对象，好的引擎也可以重用代码）。

通常，您想在最外部的位置创建该函数，在该函数中可以访问所需的所有内容。所以你的情况，这将是内部 form.on的，但外面的readFile回调。您的第二个示例正是在哪里。但是，如果愿意，您可以像第一个示例一样使用命名函数，只需将其放在 form.on的回调中即可：

form.on('file', function(name, file){
   fs.readFile(file.path, readFileCallback);
   function readFileCallback(err, contents){
      console.log(file);
      if (err) throw err;
      .... 
   }
});

让我们举一个例子，其中所有的东西都有一个简单的名称，然后执行两次调用：

function outer(outerArg) {
    function middle(middleArg) {
        function inner(innerArg) {
            console.log("innerArg = " + innerArg);
            console.log("middleArg = " + middleArg);
            console.log("outerArg = " + outerArg);
        }

        inner(middleArg.toLowerCase());
    }

    middle(outerArg.toUpperCase());
}

outer包含middle其中包含inner和outer电话middle（和middle电话inner）。一个电话：

outer("Test1");

1. outer 获取arg "Test1"
2. 它middle与"TEST1"
3. 它inner与"test1"

4. inner 输出：

   
   innerArg = test1 middleArg = TEST1 
   externalArg = Test1
   

到目前为止，如此简单，但是比这更令人兴奋：如果middle返回一个函数调用inner，而不是立即调用它，然后outer返回middlereturn的返回值，该怎么办？

function outer(outerArg) {
    function middle(middleArg) {
        function inner(innerArg) {
            console.log("innerArg = " + innerArg);
            console.log("middleArg = " + middleArg);
            console.log("outerArg = " + outerArg);
        }
        function caller() {                         // ***
            inner(middleArg.toLowerCase());         // ***
        }                                           // ***
        return caller;                              // ***
    }

    return middle(outerArg.toUpperCase());          // ***
}

现在，调用outer根本没有任何输出：

var f = outer("Test2");

但是，然后调用middle返回的函数（caller）可以：

f();

输出：

innerArg = test2 middleArg = TEST2 
externalArg = Test2

参数仍然存在，outer然后middle返回！但这更有趣：

var f1 = outer("Test3");
var f2 = outer("Test4");
f2();  // Note -- calling the second one first
f1();

输出：

innerArg = test4 middleArg = TEST4 
externalArg = Test4 
innerArg = 
test3 middleArg = TEST3 
externalArg = Test3

因此，这两个调用都结束后，仍然存在两个 outerArgsouter和两个 middleArgs。如何？

它们存在于附加到功能的对象上：

• 调用outer会创建一个执行上下文（一个对象），除其他事项外（还有很多细节），该上下文包含该调用和的参数和局部变量outer。我们称其为“外部上下文”。它还引用了包含它的执行上下文（在我们的代码中为全局上下文）。通常，当函数返回时，该对象会被清理...
• ...但是outer创建一个函数，middle。创建函数时，当前执行上下文将附加到该函数。这样便可以在外部环境中访问变量等。
• outer调用middle，创建一个内部执行上下文，并middle创建两个其他函数（inner和caller），每个函数都将其附加到该内部上下文。middle然后返回 caller，因此caller在调用middle完成后存在。由于caller具有对内部执行上下文的引用，因此即使middle返回了上下文，该上下文仍将继续存在（就像其他任何对象一样）。由于该上下文引用inner，因此inner 也继续存在。
• outer返回middle（是caller）的返回值，因此，caller当outer返回时，意味着仍然存在，这意味着它所引用的内部上下文仍然存在，这意味着inner仍然存在，并且外部上下文仍然存在，因为内部上下文对它的引用。

......这是怎么f1和f2访问后这些参数outer的回报：当您运行他们，他们查找在附属于他们的背景值。