如何一次处理多个 Promise

Question

我正在创建一个程序...

           1. 检测任何给定系统上的所有驱动器。

           2. 扫描这些驱动器以查找特定文件类型的文件。例如，
              它可能会在所有驱动器中搜索任何 jpeg、png 和 svg 文件。

           3. 然后将结果以以下所需格式存储在 JSON 文件中。

{
  "C:": {
    "jpeg": [
      ...
      {
        "path": "C:\\Users\\John\\Pictures\\example.jpeg",
        "name": "example",
        "type": "jpeg",
        "size": 86016
      },
      ...
    ],
    "png": [],
    "svg": []
  },
  ...
}

代码...

async function scan(path, exts) {
  try {
    const stats = await fsp.stat(path)
    if (stats.isDirectory()) {
      const
        childPaths = await fsp.readdir(path),
        promises = childPaths.map( 
          childPath => scan(join(path, childPath), exts)
        ),
        results = await Promise.all(promises)


      // Likely needs to change.
      return [].concat(...results)


    } else if (stats.isFile()) {
      const fileExt = extname(path).replace('.', '')
      if (exts.includes(fileExt)){


        // Likely needs to change.
        return {
          "path": path,
          "name": basename(path, fileExt).slice(0, -1),
          "type": fileExt,
          "size": stats.size
        }


      }
    }
    return []
  }
  catch (error) {
    return []
  }
}


const results = await Promise.all(
  config.drives.map(drive => scan(drive, exts))
)

console.log(results) // [ Array(140), Array(0), ... ]

// And I would like to do something like the following...

for (const drive of results) {
  const
    root = parse(path).root,
    fileExt = extname(path).replace('.', '')
  data[root][fileExt] = []
}

await fsp.writeFile('./data.json', JSON.stringify(config, null, 2))

全局results 当然被划分为与每个驱动器对应的单独数组。但目前它将所有对象组合成一个巨大的数组，尽管它们有相应的文件类型。我目前也无法知道每个驱动器属于哪个数组，尤其是如果驱动器的数组不包含任何我可以解析以检索根目录的项目。

我显然可以map 或再次循环通过全局results，然后将所有内容整理出来，如下图所示，但是让scan() 从一开始就处理所有事情会更干净。

// Initiate scan sequence.
async function initiateScan(exts) {
  let
    [config, data] = await Promise.all([
      readJson('./config.json'),
      readJson('./data.json')
    ]),
    results = await Promise.all(
      // config.drives.map(drive => scan(drive, exts))
      ['K:', 'D:'].map(drive => scan(drive, exts))
    )
  for (const drive of results) {
    let root = false
    for (const [i, file] of drive.entries()) {
      if (!root) root = parse(file.path).root.slice(0,-1)
      if (!data[root][file.type] || !i) data[root][file.type] = []
      data[root][file.type].push(file)
    }
  }
  await fsp.writeFile('./data.json', JSON.stringify(config, null, 2))
}

由于我对异步和一般对象缺乏经验，我不太确定如何最好地处理map( ... )/scan 中的数据。我什至不确定如何最好地构造scan() 的输出，以便全局results 的结构易于操作。

任何帮助将不胜感激。

Answer 1

在异步派生的结果到达时改变外部对象并不是特别干净，但是它可以相当简单和安全地完成，如下所示：

(async function(exts, results) { // async IIFE wrapper
    async function scan(path) { // lightly modified version of scan() from the question.
        try {
            const stats = await fsp.stat(path);
            if (stats.isDirectory()) {
                const childPaths = await fsp.readdir(path);
                const promises = childPaths.map(childPath => scan(join(path, childPath)));
                return Promise.all(promises);
            } else if (stats.isFile()) {
                const fileExt = extname(path).replace('.', '');
                if (results[path] && results[path][fileExt]) {
                    results[path][fileExt].push({
                        'path': path,
                        'name': basename(path, fileExt).slice(0, -1),
                        'type': fileExt,
                        'size': stats.size
                    });
                }
            }
        }
        catch (error) {
            console.log(error);
            // swallow error by not rethrowing
        }
    }
    await Promise.all(config.drives.map(path => {
        // Synchronously seed the results object with the required data structure
        results[path] = {};
        for (fileExt of exts) {
            results[path][fileExt] = []; // array will populated with data, or remain empty if no qualifying data is found.
        }
        // Asynchronously populate the results[path] object, and return Promise to the .map() callback
        return scan(path);
    }));
    console.log(results);
    // Here: whatever else you want to do with the results.
})(exts, {}); // pass `exts` and an empty results object to the IIFE function.

结果对象使用空数据结构同步播种，然后异步填充。

所有内容都包含在异步立即调用函数表达式 (IIFE) 中，因此：

• 避免使用全局命名空间（如果尚未避免）
• 确保await 的可用性（如果尚不可用）
• 为results 对象创建一个安全的闭包。

Answer 2

这还需要一些工作，它正在第二次迭代生成的文件集合。

// This should get you an object with one property per drive
const results = Object.fromEntries(
  (await Promise.all(
      config.drives.map(async drive => [drive, await scan(drive, exts)])
    )
  )
  .map(
    ([drive, files]) => [
      drive,
      // we reduce each drive's file array to an object with
      // one property per file extension
      files.reduce(
        (acc, file) => {
          acc[file.type].push(file)
          return acc
        },
        Object.fromEntries(exts.map(ext => [ext, []]))
      )
    ]
  )
)

nodejs 从 12.0.0 版本开始支持 Object.fromEntries，所以如果你能保证你的应用程序将始终在该版本或更高版本中运行，Object.fromEntries 在这里应该没问题。

Answer 3

您可以使用glob npm library 获取所有文件名，然后将该数组转换为您的对象，如下所示：

import {basename, extname} from 'path';
import {stat} from 'fs/promises'; // Or whichever library you use to promisify fs
import * as glob from "glob";

function searchForFiles() {
    return new Promise((resolve, reject) => glob(
        "/**/*.{jpeg,jpg,png,svg}", // The files to search for and where
        { silent: true, strict: false}, // No error when eg. something cannot be accessed 
        (err, files) => err ? reject() : resolve(files)
    ));
}

async function getFileObject() {
    const fileNames = await searchForFiles(); // An array containing all file names (eg. ['D:\\my\path\to\file.jpeg', 'C:\\otherfile.svg'])

    // An array containing all objects describing your file
    const fileObjects = await Promise.all(fileNames.map(async filename => ({ 
        path: filename,
        name: basename(path, fileExt).slice(0, -1),
        type: extname(path).replace('.', ''),
        size: stat(path).size,
        drive: `${filename.split(':\\')[0]}:`
    })));

    // Create your actual object
    return fileObjects.reduce((result, {path, name, type, size, drive}) => {
        if (!result[drive]) { // create eg. { C: {} } if it does not already exist
            result.drive = {};
        }
        if (!result[drive][type]) { // create eg. {C: { jpeg: [] }} if it does not already exist
            result[drive][type] = [];
        }
        // Push the object to the correct array
        result[drive][type].push({path, name, type, size});
        return result;
    }, {});
}

Answer 4

该函数必须递归遍历文件系统，寻找符合您条件的文件。由于结果不需要保留任何层次结构，因此可以简化递归，因此我们可以只携带一个平面数组 (files) 作为参数。

let exts = [...]

async function scan(path, files) {
  const stats = await fsp.stat(path)
  if (stats.isDirectory()) {
    childPaths = await fsp.readdir(path)
    let promises = childPaths.map(childPath => {
      return scan(join(path, childPath), files)
    })
    return Promise.all(promises)
  } else if (stats.isFile()) {
    const fileExt = extname(path).replace('.', '')
    if (exts.includes(fileExt)) {
      files.push({
        path: path,
        name: basename(path, fileExt).slice(0, -1),
        type: fileExt,
        size: stats.size
      })
    }
  }
}

let files = []
await scan('/', files)
console.log(files)