Node 中的顺序功能

它基本上是串行或同步执行异步任务。 Java本质上是异步的，Node.js 也是如此。 Node 通过使用事件循环和回调函数同时处理多个请求。
有两种方法可以同步或顺序执行不同的异步功能：
1. 使用回调函数：它是节点中的事件处理程序。该函数通常在给定任务完成时调用。使用循环所需的回调并行读取文件。为了顺序读取文件，它需要一个递归函数。此函数检查是否已到达最后一个文件。如果是，则完成，否则它将继续读取下一个文件。以下示例的代码如下：

代码是使用回调依次读取文件夹中的所有文件。
要读取文件夹中的文件，我们首先必须查看文件夹中的所有文件。

示例#1

// fs is a built in module to handle the file system
// Require function is used to include the module
// followed by module's name
var fs = require("fs");
  
// Start with readdir() function and wait for the
// operation to complete
fs.readdir( "...", function( err, files ) {
    if ( err ) {
  
        // Console.log is used to print the
        // result as it is
        console.log("Error in file contents.");
    } 
    else {
  
        // It will start reading files from index 0
        var ttlBytes = 0;
  
        // This function repeatedly calls itself
        // until all the files are read
        var readFiles = function(index) {
            if ( index == files.length ) {
                console.log( "Done reading all the files. ttlBytes = "
                        + ttlBytes );
            } 
            else {
                  
                // For each file we use readFile() to get
                // the contents of the file
                fs.readFile( files[index], function( err, data ) {
                    if ( error ) {
                        console.log( "Error reading the file", err );
                    } else {
                        ttlBytes += data.length;
                        readFiles(index+1);
                    }
                });
            }
       };
       readFiles(0);
   }
});

2. 使用 Promises：这是 Node.js 中避免回调地狱的一种设计模式。引入这些是为了降低异步 JavaScript 代码的复杂性。
一个 promise 有 3 个状态：

待定：您不知道人们是否会来参加您的生日聚会。
拒绝：如果承诺被拒绝，则表示人们拒绝参加您的生日聚会。
已解决：如果承诺已解决，则表示人们已准备好参加您的生日聚会。

以下示例的代码如下：
示例#2

const arePeopleReady = true;
  
// Promise accepts executor function as argument
const invitationBirthday = new Promise((resolve, reject) => {
    if (arePeopleReady) {
        return resolve('People are ready to come to your Birthday party');
    } else {
        var reason = new Error('People are not Ready');
        return reject(reason);
    }
});
  
// Call our promise
const askPeople = () => {
    invitationBirthday
        .then((fulfilled) => {
              
            // Awesome!, People have accepted your invitation
            console.log(fulfilled);
        })
        .catch(error => {
              
            // Hard luck, people are not ready 
            console.log(error.message);
        });
}
askPeople();

在 Node.js 中避免回调地狱的其他设计方法如下：

使用 Async.series 连续执行任务。
使用 Async/Await 连续执行任务。
使用 Async.waterfall 连续执行任务。

3. 使用异步/等待
Async/Await 的示例可以如下所示：

在这个例子中，为了简单起见，我们不使用拒绝/错误
异步函数返回一个 Promise
如果函数显示错误，Promise 将被拒绝。如果函数返回一个值，Promise 将被解析。

示例#3

// A function is created that accepts only one parameter
// Resolve method is called on this promise
// setTimeout is used to simulate a blocking Async operation
function addIntAfter4Seconds(x) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(x + 4);
    }, 2000);
  });
}
// Await expression will pause the async function
// and wait for the promise to resolve before moving forward
// addAsync is used to set up a promise chain
async function addAsync(x) {
  const a = await addIntAfter4Seconds(10);
  const b = await addIntAfter4Seconds(20);
  const c = await addIntAfter4Seconds(30);
  return x + a + b + c;
}
  
// then method to conclude the logic
// the returned value is logged to the console
addAsync(x).then((sum) => {
  console.log(sum);
});

输出：