Javascript 从dropbox.js findByName方法（）获取值？

在我提出这个问题之前，我绝对不是一个流利的javascript开发人员。我来自OOP背景，所以整个异步调用/传递方法都很奇怪

无论如何，我使用的是dropbox.js SDK，特别是以下方法（如文档中所述）：

（XMLHttpRequest）findByName（路径、命名模式、选项、回调）

我有一个循环查找的文件扩展名列表，为每个扩展名调用

findByName

var file_extensions = [".py", ".cpp", ".erl"];

function look_for_files(directory_path, file_extensions){
    // To hold counts for each file extension
    var count_dict = [];

    for (var i = 0; i < file_extensions.length; i++){

        var current_file = file_extensions[i];

        client.findByName(PATH, current_file, function(error, count){
            if(error){ 
                return showError(error);
            }
            else {
                count_dict.push(count.length);
            }
        });
    }
    console.log(count_dict);
};

var文件扩展名=[“.py”、“.cpp”、“.erl”]；
函数查找文件（目录路径、文件扩展名）{
//保存每个文件扩展名的计数
var count_dict=[]；
对于（var i=0；i

如您所见，我只是尝试每次调用该方法并将其返回到名为

count\u dict

的列表中。但是，我似乎无法将此值放入

findByName方法中的列表中。

我确信这是因为我误解了回调以及这一切是如何工作的，但也许有人可以帮助我吗

---

谢谢您运行此代码将有助于您了解问题：

function do_one_thing(thing, callback) {
    // Invoke the callback one second later (simulating an async network call)
    window.setTimeout(function () {
        callback('Done with ' + thing)
    }, 1000);
}

function do_things(things) {
    for (var i = 0; i < things.length; i++) {
        do_one_thing(things[i], function (result) {
            console.log('Got result: ' + result);
        });
    }
    console.log('Outside of loop.');
}

do_things(["one", "two", "three"]);

回到您的代码，您将启动三个网络呼叫，然后打印空列表，然后网络呼叫完成

有几个选项可以解决这个问题。我最喜欢使用promises库，如：

通过这种方式，所有调用都可以并发运行，但只有在它们全部完成时才能得到结果

另一种选择是使用自己的机制等待完成：

function do_one_thing(thing, callback) {
    // Invoke the callback one second later (simulating an async network call)
    window.setTimeout(function () {
        callback('Done with ' + thing);
    }, 1000);
}

function do_things(things, callback) {
    var results = [];
    var pending = things.length;

    for (var i = 0; i < things.length; i++) {
        // "index" just captures the current value of "i"
        (function (index) {
            do_one_thing(things[index], function (result) {
                // Store the results in the right place.
                results[index] = result;
                // Decrement the pending count.
                pending -= 1;

                // If we're all done, invoke the callback with the full results.
                if (pending === 0) {
                    callback(results);
                }
            });
        })(i);
    }
}

do_things(["one", "two", "three"], function (results) {
    console.log('All done!');
    console.log(results);
});

函数做一件事（事，回调）{
//一秒钟后调用回调（模拟异步网络调用）
setTimeout（函数（）{
回调（'Done with'+thing）；
}, 1000);
}
函数do_things（things，callback）{
var结果=[]；
var pending=things.length；
for（var i=0；i

---

底线是，由于每个调用都是异步的，它们可能以任何顺序返回，因此您需要某种方式等待它们全部完成，然后以回调的形式提供调用代码的答案。

客户端。findByName

是异步的，您的代码不考虑这一点。下面的代码通过检查count_dict中的条目数并等待所有网络调用返回来修复此问题

var file_extensions = [".py", ".cpp", ".erl"];

function look_for_files(directory_path, file_extensions){

  // To hold counts for each file extension
  var count_dict = [];

  countExtensions(file_extensions, function(){
    console.log(count_dict)
  });

  function countExtensions (file_extensions, callback) {

    for (var i = 0; i < file_extensions.length; i++) {

      var current_file = file_extensions[i];

      client.findByName(PATH, current_file, function(error, count){
        if(error) return showError(error);
        count_dict.push(count.length);
        if (count_dict.length === file_extensions.length) return callback();
      });
    }    
  }
};

var文件扩展名=[“.py”、“.cpp”、“.erl”]；
函数查找文件（目录路径、文件扩展名）{
//保存每个文件扩展名的计数
var count_dict=[]；
countExtensions（文件扩展名，函数（）{
控制台日志（计数记录）
});
函数扩展名（文件扩展名、回调）{
对于（var i=0；i

除了结尾的console.log语句外，您是否在检查count\u dict是否仍然为空？因为如果不是，这可能确实是由请求的异步性质引起的问题——即，代码可能在任何回调发生之前到达console.log语句。如果我正确理解此代码，一次只能进行一次网络调用，对吗？这比我下面的代码简单，但我认为通常最好一次启动所有异步调用。此版本的代码并行启动所有调用，但我根据每次调用返回的时间，结果可能会出错（与输入不匹配）。

function do_one_thing(thing, callback) {
    // Invoke the callback one second later (simulating an async network call)
    window.setTimeout(function () {
        callback('Done with ' + thing);
    }, 1000);
}

function do_things(things, callback) {
    var results = [];
    var pending = things.length;

    for (var i = 0; i < things.length; i++) {
        // "index" just captures the current value of "i"
        (function (index) {
            do_one_thing(things[index], function (result) {
                // Store the results in the right place.
                results[index] = result;
                // Decrement the pending count.
                pending -= 1;

                // If we're all done, invoke the callback with the full results.
                if (pending === 0) {
                    callback(results);
                }
            });
        })(i);
    }
}

do_things(["one", "two", "three"], function (results) {
    console.log('All done!');
    console.log(results);
});

var file_extensions = [".py", ".cpp", ".erl"];

function look_for_files(directory_path, file_extensions){

  // To hold counts for each file extension
  var count_dict = [];

  countExtensions(file_extensions, function(){
    console.log(count_dict)
  });

  function countExtensions (file_extensions, callback) {

    for (var i = 0; i < file_extensions.length; i++) {

      var current_file = file_extensions[i];

      client.findByName(PATH, current_file, function(error, count){
        if(error) return showError(error);
        count_dict.push(count.length);
        if (count_dict.length === file_extensions.length) return callback();
      });
    }    
  }
};