在 Node 中以 fs.readFile 顺序读取文件？

Question

我将任意数量的文件路径作为字符串存储在数组中。

我需要依次读取这些文件（即读完一个文件再开始读取下一个文件），并在每次读取文件后输出文件长度。读取完所有文件后，打印 'done'.

我只能使用 fs.readFile 和原生 Javascript。不允许 fs.readFileSync 或任何其他模块。另外，我在 Node v6 上，所以我不能使用 async/await.

有没有什么方法可以在约束条件下实现功能？

Answer 1

Read files synchronously with fs.readFile in Node?

没有

异步函数是异步的。

它们不能变成同步函数。

即使您可以使用 await（您已排除），它仍然是异步的，只是语法允许您以同步 风格编写代码 在更广泛的上下文中，即仍然异步。

大部分 JavaScript 是异步的。接受它。精益使用承诺。不要试图与之抗争。

I need to read these files in sequence (i.e. finish reading one file before starting reading the next one), and output the file length after each file read. And after finish reading all files, print 'done'.

编写一个沿数组迭代的递归函数。读取文件后，增加迭代器并递归或打印 done 取决于您是在数组末尾还是现在。

Answer 2

尝试使用 generators。在示例代码中，将异步函数替换为读取文件。

// emulate async action
const stt = (resolve, str) => {
  setTimeout(
    () => {
      console.log(str);
      resolve(str);
    },
    2000
  );
}
// Create array of functions that return Promise
const arrFunc = ['foo', 'bar', 'baz', 'qux']
  .reduce(
    (acc, str) => {
      acc.push(() => {
        return new Promise(resolve => {
          stt(resolve, str);
        });
      });
      return acc;
    }, []
  );

function* generator() {
  for (let func of arrFunc) {
    yield func();
  }
}

const iterator = generator();

function quasiCo(generator, value) {
  const next = generator.next();
  console.log(next);
  if (!next.done) {
    next.value.then(res => {
      quasiCo(generator, res);
    });
  }
}

quasiCo(iterator);

Answer 3

您不需要像 promises、async/await、生成器这样花哨的东西来实现它。

function readAllFiles(list) {
  if(list.length == 0) return
  console.log('reading ', list[0])
  return fs.readFile(list[0], function (err, file) {
    if (err) console.error(err); // report the error and continue
    console.log('list[0] length:', file.length); // report the file length
    readAllFiles(list.slice(1, list.length))
  })
}

var l = ['1', 'foo', 'bar']

readAllFiles(l)

在 Node 中以 fs.readFile 顺序读取文件？

Read files in series with fs.readFile in Node?

javascript

node.js

asynchronous

fs

synchronous