JavaScript：异步函数

我试图了解异步代码的概念，所以我制作了以下代码：

"use strict";
var fs = require("fs");
var buf = new Buffer(1024);

console.log("Global Start");
console.log("+++ Async open - truncate - close: open file2 called");
fs.open("file2.txt", "r+", function (err, fd) {
  console.log(" Global + 1 Start");
  if (err) {
    return console.error(err);
  }
  console.log(" +++ Async file2 opened successfully!");

  // Truncate the opened file.
  console.log(" +++ Async open - truncate - close: truncate file2 called");
  fs.ftruncate(fd, 10, function (err) {
    console.log("       Global + 2 Start");
    if (err) {
      console.log(err);
    }
    console.log("       +++ truncate file2 successfully!");
    console.log("       +++ Async open - truncate - close: read file2 called");
    fs.read(fd, buf, 0, buf.length, 0, function (err, bytes) {
      console.log("         Global + 3 Start");
      if (err) {
        console.log(err);
      }
      // Print only read bytes to avoid junk.
      if (bytes > 0) {
        console.log("           Global + 3 +++ truncate read: '" + buf.slice(0, bytes).toString() + "'");
      }

      // Close the opened file.
      console.log("         Global + 3 +++ truncate - open - close: close file2 called");
      fs.close(fd, function (err) {
        console.log("               Global + 4 Start");
        if (err) {
          console.log(err);
        }
        console.log("               Global + 4 ++++++++++++++++++++ Async open - truncate - close file2 + closed ++++++++++++++++++++");
        console.log("               Global + 4 End");
      });

      console.log("         Global + 3 End");
    });
    console.log("       Global + 2 End");
  });
  console.log(" Global + 1 End");
});
console.log("Global End");

其中创建了以下输出。

Global Start
+++ Async open - truncate - close: open file2 called
Global End
        Global + 1 Start
        +++ Async file2 opened successfully!
        +++ Async open - truncate - close: truncate file2 called
        Global + 1 End
                Global + 2 Start
                +++ truncate file2 successfully!
                +++ Async open - truncate - close: read file2 called
                Global + 2 End
                        Global + 3 Start
                        Global + 3 +++ truncate read: 'This is a '
                        Global + 3 +++ truncate - open - close: close file2 called
                        Global + 3 End
                                Global + 4 Start
                                Global + 4 ++++++++++++++++++++ Async open - truncate - close file2 + closed ++++++++++++++++++++
                                Global + 4 End

所以这就是我的意思：

1. 全球范围：“全球开始”
2. 使用回调函数调用fs.open，该函数在fs.open完成后会执行。

3. fs.open开始工作，而不是等待结果，而是执行全局级别的下一个任务，即“ Global End”。

4. 现在完成fs.open并调用回调函数。我们进入“全局+1”范围。

5. 全局+1范围：“全局+1开始”

6. 使用完成fs.ftruncate后执行的回调函数调用fs.ftruncate

7. fs.ftruncate开始工作，并且在工作时，将执行Global +1范围上的其余代码，即“ Global +1 End”。

8. fs.ftruncate完成后，将调用其回调函数。

全局+ 3和全局+ 4遵循相同的模式。

所以我的问题是；

我对代码中发生的情况的描述正确吗？

在我看来，异步代码是从最外面的括号（全局范围）到最里面的括号（全局+ 4范围）执行的。它不是从最内层到最外层（如数学中的），也不是从顶线到but线（如同步代码）。那是对的吗？

如果完成了Global Scope上的一个函数并在完成Global Scope上的其他代码之前执行了其回调函数，将会发生什么情况。回调会等待全局代码完成吗？

如果对不同的文件执行相同的代码要花费不同的时间来处理，那么输出的结果是否会以不同的顺序出现？