Question

我正在构建一个使用glob和q的脚本。我希望能够发送一个字符串"src/**/*.js"，并让它在每个路径名上调用一个函数。我想扩展它，所以我可以传递一个像["stage1/**/*.js", "stage2/**/*.js"]甚至[["stage1/**/*.js", "stage2/**/*.js"], "stage3/**/*.js"]这样的数组，基本上让我随意定义顺序依赖，而不是实际关注组内的顺序。

我想出了以下脚本：

var Q = require("q");
var glob = require("glob");

function type(value) {
  return Object.prototype.toString.call(value);
}

function iterate(spec, options, callback) {
  if (spec instanceof Array) {
    // convert spec into list of promises
    var promises = spec.map(function(spec) {
      return iterate(spec, options, callback);
    });

    // reduce promises into chain
    return promises.reduce(function(previous, current) {
      return previous.then(current);
    });
  } else if (type(spec) === "[object String]") {
    return Q.nfcall(glob, spec, options)
      .then(function(files) {
        // map files into list of promises
        var promises = files.map(function(file) {
          return Q.Promise(function(resolve, reject) {
            try {
              callback(file, resolve);
            } catch (error) {
              reject(error);
            }
          });
        });

        // wait for all promises to complete
        return Q.all(promises);
      });
  } else {
    throw new Error("The value passed in must be a string, or array of strings.");
  }
};

module.exports = function(spec, options, callback, finished) {
  options = options || {};
  callback = callback || function(file, resolved) {
    resolved();
  };
  finished = finished || function(error) {
    error ? finished(error) : finished(null);
  };

  iterate(spec, options, callback)
    .then(function() {
      finished(null);
    })
    .fail(function(error) {
      finished(error);
    })
    .done();
};

它使用递归对事物进行排队，然后公开一个看起来很正常的nodejs接口。这是使用上述模块的index.js文件。

var example = require("./lib/example");

var files = [
  [
    "./node_modules/q/**/*.json",
    "./node_modules/q/**/*.js"
  ],
  "./node_modules/glob/*.json",
  "./node_modules/glob/*.js"
];

example(files, {}, listFile, finished);

function listFile(filename, done) {
  console.log(filename);
  done();
}

function finished(error) {
  if (error) {
    console.log(error);
  } else {
    console.log("finished");
  }
}

据我所知，文档应该可行。但是，如果我使用一个返回一堆文件的glob，那么在完成所有文件打印之前将打印“已完成”的文本。

我认为是Q.all()的使用，以及某种检查完成的失败。但实际上Q.all()似乎有效，从来没有错过任何文件。奇怪的是，从我所知道的then中promises.reduce()操作链接似乎并没有等到其他承诺完成。甚至似乎完全忽略了then链的顺序......

我想也许console.log是异步行动的，但根据其他帖子，在我的情况下，console.log应该是同步操作......有人可以在这里看到我对此有何误解，或者发现一个我错过的错误？

Answer 1

问题是你的迭代器函数的if else子句可以返回两个单独的promise：

function iterate(spec, options, callback, previousPromise) {
  if (spec instanceof Array) {
    previousPromise.then(function(){
      return doStuff();
    })
  } else if (type(spec) === "[object String]") {
    previousPromise.then(function(){
      return doStuff();
    })
  }
  return previousPromise;
};

他们也需要被链接：

function getPromise(){
    var deferred = Q.defer();
    deferred.resolve();
    return deferred.promise;
}

function iterate(spec, options, callback, promiseChain) {
    console.log('spec:', spec);
    promiseChain = promiseChain || getPromise();
    if (spec instanceof Array) {
        promiseChain = promiseChain.then(function() {
            return spec.reduce(function(promiseChain, spec) {
                return promiseChain.then(function() {
                    return iterate(spec, options, callback, promiseChain);
                });
            }, getPromise());
        })
    } else if (type(spec) === "[object String]") {
        promiseChain = promiseChain.then(function() {
            return Q.nfcall(glob, spec, options)
                .then(function(files) {
                    console.log('files:', files);
                    // map files into list of promises
                    var promises = files.map(function(file) {
                        return Q.Promise(function(resolve, reject) {
                            try {
                                callback(file, resolve);
                            } catch (error) {
                                reject(error);
                            }
                        });
                    });

                    // wait for all promises to complete
                    return Q.all(promises);
                });
        });
    } else {
        throw new Error("The value passed in must be a string, or array of strings.");
    }
    return promiseChain;
};

我已经想出了这个，但我对Q（主要是如何获得一个已经解决的承诺）不熟悉，所以我相信你可以改进它：

{{1}}

Q承诺不按预期解决

1 个答案: