Javascript 如何在JS中的回调中等待其他结果

我正在创建一个读取PDF文件并将其转换为CSV的代码。代码一次读取一个文件就可以工作。现在我尝试一次读取多个文件，并解释代码：

我的bin/www将通过命令行初始化代码：

Command: node bin/www oneArchive.pdf twoArchive.pdf

'use strict';
var Break = require('../core');

var node    = process.argv[0];
var script  = process.argv[1];
var length  = process.argv.length;
var files   = [];

if (length > 2) {
    for (var i = 2; i < length; i++) {
        files.push(process.argv[i]);
    }

    Break.extract(files);
}

我还有其他阶段，但我现在需要做的是提取阶段，我发送一个带有文件名的数组，这个阶段只读取文件中的文本

我在这个阶段的需要是获取我在一个数组中发送的文件，在另一个数组中变成相同的文本文件，然后将它们发送到下一个阶段，这与现在无关

继续

因此，在提取阶段发送：

var Extract = {
    init: function(files, callback) {
        this.files      = files;
        this.callback   = callback;

        SeparateFiles.init(files, Extract.result);
    },

    result: function(files) {        
        console.log(files);
    }
};

这是我认为最重要的部分，我希望分离文件并在result方法中返回一个数组，其中包含文本

因此：

分离文件：

var SeparateFiles = {
    init: function(files, callback) {
        for (var i = 0; i < files.length; i++) {
            Types.read(files[i], 'pdf', callback);
        }
    }
};

这里的问题是，我正在接收一个文本，另一个文本，我希望在一个数组中同时接收这两个文本

这里的问题是循环，我想，我知道如何在两个文件中应用逻辑，然后发送到结果方法，但我想应用逻辑，等待完成，然后发送到结果

---

读取逻辑非常大，我无法粘贴到这里，但我有几种方法，最后我只将文本发送到result方法。

Javascript承诺？

如果您要进行复杂的异步操作，那么使用它可能值得一看。虽然传统浏览器并不广泛支持它们，但有许多多边形填充可以填补这些空白

使用Promissions，如果要等待两个单独的异步操作完成后再继续，可以执行以下操作：

Promise.all([async1, async2])
       .then(function() {
            //Only when both async1 and async2 have been resolved
            //(completed without failure) does this code execute
        });

这是关于JS的承诺

以下是承诺（这实际上在上面的文章中有链接）

---

希望这有帮助

我认为问题在于

separatefile.init的
回调
对每个
类型调用一次。read
completion，只有在处理完所有文件后才应该调用它

在这个包中，有一个
map
函数正好可以做到这一点

否则，您需要自己编写代码。比如：

var SeparateFiles = {
    init: function(files, callback) {
        var result = [];  // This will be passed to the final callback
        for (var i = 0; i < files.length; i++) {
            Types.read(files[i], 'pdf', function(err, text) {
               if (err) {
                   callback(err);
                   return;
               }
               result.push(text);  // Add the Type.read output to the callback result array
               if (result.length === files.length) { // Done??
                   callback(null, result); // Invoke final callback
               }
            });
        }
    }
};

var separatefile={
init：函数（文件、回调）{
var result=[]；//这将传递给最终回调
对于（var i=0；i
您似乎在描述异步操作，但您的代码看起来是同步的。。。我想你漏掉了最重要的部分，那就是你阅读文件的部分。什么是
类型。阅读
。正如@elclanrs指出的，您的代码的执行就像您在执行同步操作一样。
/// ALL THE LOGIC TO BREAK THE FILE

When you finish, send to callback function, which is the result method.

Promise.all([async1, async2])
       .then(function() {
            //Only when both async1 and async2 have been resolved
            //(completed without failure) does this code execute
        });

var SeparateFiles = {
    init: function(files, callback) {
        var result = [];  // This will be passed to the final callback
        for (var i = 0; i < files.length; i++) {
            Types.read(files[i], 'pdf', function(err, text) {
               if (err) {
                   callback(err);
                   return;
               }
               result.push(text);  // Add the Type.read output to the callback result array
               if (result.length === files.length) { // Done??
                   callback(null, result); // Invoke final callback
               }
            });
        }
    }
};