Node.js中ES6模块化及Promise对象

我来详细讲解一下。

Node.js中的ES6模块化

从Node.js v13.2.0版本开始，Node.js开始原生支持ES6模块化。在ES6模块化中，一个模块就是一个独立的文件，每个模块可以导出自己的内容，也可以导入其他模块的内容。ES6模块化与CommonJS模块化有所不同，需要使用不同的导入和导出语法。

导出模块

ES6模块化通过使用 export 来导出一个模块。

例如，你可以创建一个名为 module.js 的文件，并在其中导出一个字符串：

// module.js
export const message = "hello world";

上述代码使用 export 关键字导出了一个名为 message 的常量。

当这个模块被导入到其他模块中时，可以使用 import 来引入模块：

import { message } from './module.js';
console.log(message);
// 输出：hello world

上述代码使用 import 引入了 module.js 中导出的 message 常量。注意，在文件路径前必须使用 ./ 表示当前文件夹。

导入模块

ES6模块化通过使用 import 来导入其他模块。

下面的示例展示了如何从模块中导入多个值：

// module.js
export const message1 = "Hello";
export const message2 = "World";

import { message1, message2 } from './module.js';
console.log(`${message1} ${message2}`);
// 输出：Hello World

上述代码中，我们从 module.js 中导出了两个变量：message1 和 message2。在另一个文件中，使用 import 导入了这两个变量，并拼接出了一个新的字符串。

加载ES6模块

在Node.js中，通过使用 .mjs 或 .js 后缀名来区分模块类型。如果使用 .js 后缀名，则默认使用CommonJS模块化加载。

然而，在使用ES6模块化时，你需要将文件后缀名改为 .mjs 。如果你不想使用 .mjs 后缀名，可以在你的项目 package.json 文件中添加一个 "type": "module" 字段来指定模块类型：

{
  "type": "module"
}

Promise对象

Promise对象是JavaScript中一种常用的异步编程语法，它可以很好地解决回调地狱的问题。Promise对象有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。

在Node.js中，很多异步操作都返回Promise对象，比如文件读写和网络请求等。

创建Promise对象

可以通过 Promise 构造函数来创建一个Promise对象。Promise构造函数的参数是一个函数，这个函数接受两个参数 resolve 和 reject ，分别代表Promise成功和失败时的回调函数。在Promise内部，通常会执行一些异步操作，并在完成时调用 resolve 或 reject 来改变Promise状态。

下面是创建一个Promise对象的示例：

let promise = new Promise(function(resolve, reject) {
  // 异步操作，比如文件读写或网络请求

  // 成功时调用resolve，将Promise状态改为fulfilled
  resolve(value);

  // 失败时调用reject，将Promise状态改为rejected
  reject(error);
});

Promise的then方法

当Promise状态变为fulfilled时会调用 then 方法中的回调函数，当Promise状态变为rejected时会调用 catch 方法中的回调函数。

下面的示例展示了如何使用Promise对象：

function readFile(filepath) {
  return new Promise(function(resolve, reject) {
    fs.readFile(filepath, function(err, data) {
      if (err) {
        reject(err);
      } else {
        resolve(data);
      }
    });
  });
}

// readFile是一个异步函数，返回一个Promise对象
readFile('./test.txt')
  .then(function(data) {
    console.log(data.toString());
  })
  .catch(function(err) {
    console.error(err);
  });

上述代码中的 readFile 函数封装了一个文件读取过程，并返回一个Promise对象。在读取成功时，调用了 resolve 方法，并传递了读取到的数据；在读取失败时，调用了 reject 方法，并传递了错误信息。

在 then 方法中，通过回调函数处理Promise成功的情况，调用 catch 方法中的回调函数处理Promise失败的情况。

Promise的链式调用

通过多次调用 then 方法可以实现Promise的链式调用。在Promise链式调用中，每个 then 中的回调函数必须返回一个新的Promise对象，否则后面的 then 方法将无法接收到返回值。

下面的示例展示了Promise的链式调用：

function readFile(filepath) {
  return new Promise(function(resolve, reject) {
    fs.readFile(filepath, function(err, data) {
      if (err) {
        reject(err);
      } else {
        resolve(data);
      }
    });
  });
}

// readFile是一个异步函数，返回一个Promise对象
readFile('./test.txt')
  .then(function(data) {
    console.log(data.toString());
    return readFile('./test2.txt'); // 返回一个新的Promise对象
  })
  .then(function(data) {
    console.log(data.toString());
  })
  .catch(function(err) {
    console.error(err);
  });

在上述示例中，我们首先读取了 test.txt 文件，并在第一个 then 中输出了读取到的数据。然后，我们调用了 readFile 函数读取一个新的文件，并将返回的新Promise对象返回给下一个 then 方法。

示例一：

下面的示例展示了从文件中读取JSON字符串，并将其解析为JavaScript对象的过程：

const fs = require('fs');

function readJsonFile(filepath) {
  return new Promise(function(resolve, reject) {
    fs.readFile(filepath, function(err, data) {
      if (err) {
        reject(err);
      } else {
        try {
          const json = JSON.parse(data.toString());
          resolve(json);
        } catch (e) {
          reject(e);
        }
      }
    });
  });
}

// readJsonFile是一个异步函数，返回一个Promise对象
readJsonFile('test.json')
  .then(function(data) {
    console.log(data);
  })
  .catch(function(err) {
    console.error(err);
  });

在上述示例中，我们定义了一个 readJsonFile 函数，用于读取JSON文件并解析为JavaScript对象。在函数内部，我们使用 fs 模块读取文件内容，并通过 JSON.parse 函数将其解析为JavaScript对象。

示例二：

下面的示例展示了如何将多个Promise对象合并为一个：

function getAllFiles() {
  const files1 = readFilesFromFolder('./folder1');
  const files2 = readFilesFromFolder('./folder2');

  // Promise.all方法可以将多个Promise对象合并为一个
  return Promise.all([files1, files2])
    .then(function([files1, files2]) {
      return files1.concat(files2);
    });
}

function readFilesFromFolder(folderpath) {
  return new Promise(function(resolve, reject) {
    fs.readdir(folderpath, function(err, files) {
      if (err) {
        reject(err);
      } else {
        const filePaths = files.map(file => path.join(folderpath, file));      
        Promise.all(filePaths.map(readFile))
          .then(function(contents) {
            const files = filePaths.map((filePath, index) => ({
              path: filePath,
              content: contents[index],
            }));
            resolve(files);
          })
          .catch(function(err) {
            reject(err);
          });
      }
    });
  });
}

// getAllFiles是一个异步函数，返回一个Promise对象，其结果是所有文件的数据组成的数组
getAllFiles()
  .then(function(files) {
    console.log(files);
  })
  .catch(function(err) {
    console.error(err);
  });

在上述示例中，我们定义了一个 getAllFiles 函数，用于返回读取两个文件夹中所有文件数据的Promise对象。在函数内部，我们同时调用了 readFilesFromFolder 函数，读取两个文件夹中所有文件的数据，并返回一个Promise对象数组。接着，调用了 Promise.all 方法将这两个Promise对象合并为一个，并在 then 方法中将结果数组合并为一个结果数组。