Javascript 如何产生延迟的结果

我正在使用ESRI Javascript API在ArcGIS服务器中检索数据集中的所有记录，以便进行客户端处理。服务器将每个响应限制为1000条记录。这意味着我必须在检索功能时跟踪它们，然后检索下一批。对检索记录的API的调用返回一个

dojo/Deferred

对象

我希望能够检索一批1000条记录，对它们进行处理，然后将它们按顺序保存回数据集。同时，一旦从数据集中检索到一批记录，就会开始检索下一批记录

我使用递归函数调用做了类似的事情，并将结果

dojo/Deferred

保存到一个列表中，以便稍后使用

dojo/promise/all

进行处理。但是，这意味着在检索完所有特征后，立即处理所有特征。我希望能够在检索每个批次时单独处理它们

我的应用程序使用带有ESRI API和jQuery/jQuery Mobile的

dojo

下面是我一次返回所有功能的代码：

//layer = dataset (geographic data)
//count = count of records (features) in dataset
//objectIds = list of all unique record ID's in dataset.  This can be retrieved from the server and is not limited by the 1000 record limit
//Query = ESRI API Query Task used to retrieve features from the dataset

if (count > layer.maxRecordCount) {

    var features = [];

    var i = 0;

    var deferreds = [];
    for (i; i < objectIds.length; i += layer.maxRecordCount) {

        var q = new Query();
        q.objectIds = objectIds.slice(i, i + layer.maxRecordCount);

        var deferred;
        if (select) { deferred = layer.selectFeatures(q, selectionType); }
        else { deferred = layer.queryFeatures(q); }

        deferreds.push(deferred);

    }

    var deferred = all(deferreds).then(function(featuresets) {

        var featureLists = array.map(featuresets, function(featureset) {
            return featureset.features || featureset;
        });

        var features = [].concat.apply([], featureLists);

        return features;

    });

    return deferred;

}

下面是处理数据的代码：

var queue = pgUtils.getAllFeatures(layer, false, [priorityField.name]);

var features = queue.shift();

var interval;

if (features === "start") {

    interval = setInterval(function() {
        features = queue.shift();
        if (features && features instanceof Array) {
            self._prioritize(features, formData);
            new esriRequest({
                url : layer.url + "/applyEdits",
                content : {
                    f : "json",
                    updates : JSON.stringify(features)
                }
            }, {usePost : true});
        } else if (features === "stop") {
            clearInterval(interval);
        }
    }, 500);
}

---

如您所见，我使用名为

queue

的

Array

在

getAllFeatures

函数中推送单个响应，并使用

setInterval

从

queue

检索这些响应，直到找到

“stop”

信号。到目前为止，这似乎与我的450条记录的测试数据集有关。我还不确定这将如何适用于更大的数据集。我当然愿意接受任何关于更好方法的建议。

查看延迟列表

var def_array = [];
for(..) {
  var def = new Deferred();
   ...
  def_array.push(def);
}
new DeferredList(def_array).then(function(res){
   ...
   //this runs only all the deferreds in the def_array is invoked and completed
});

---

DeferredList还有许多其他参数/标志，这些参数/标志根据需求用于特定目的。但是，对于您的情况，我想，上述解决方案已经足够了。

如果我正确地解释了您的问题，您基本上希望以串行方式而不是并行方式请求批次，在请求下一个批次之前处理每个批次。正如您所注意到的，

all

确实适合并行处理。你需要一种不同的方法来做你想做的事情（注意我没有办法测试它，所以它可能还需要一些工作）：

var i=0，
len=objectIds.length，
特征=[]；
函数requestNext（）{
var q=新查询（），
承诺；
q、 objectIds=objectIds.slice（i，i+layer.maxRecordCount）；
promise=select？图层。selectFeatures（q，selectionType）：
图层查询特征（q）；
返回承诺。然后（函数（featureset）{
//将最新的结果集添加到要素阵列
features=features.concat（featureset.features | | featureset）；
//如果要查询更多对象，请再次调用此函数，
//将后续请求的决议与本承诺挂钩；
//否则，返回构建的特征数组
i+=layer.maxRecordCount；
返回i

谢谢你的建议。在dojo 1.9中，不推荐使用延迟列表。相反，他们建议使用

dojo/promise/all

，这就是我在上面发布的代码中使用的。不幸的是，无论我使用

all

还是

delferredlist

，它都意味着等待所有批次完成，然后完成处理。我试图一次独立于其他批次处理批处理。实际上，我试图并行处理所有事情。目前，我发布的函数向服务器提交多个

Query

请求，但在使用

all

返回任何功能之前，等待所有响应。我正在寻找一个函数，它并行发送请求并返回响应。

var def_array = [];
for(..) {
  var def = new Deferred();
   ...
  def_array.push(def);
}
new DeferredList(def_array).then(function(res){
   ...
   //this runs only all the deferreds in the def_array is invoked and completed
});

var i = 0,
    len = objectIds.length,
    features = [];

function requestNext() {
    var q = new Query(),
        promise;

    q.objectIds = objectIds.slice(i, i + layer.maxRecordCount);
    promise = select ? layer.selectFeatures(q, selectionType) :
        layer.queryFeatures(q);

    return promise.then(function (featureset) {
        // Add the latest set of results to the features array
        features = features.concat(featureset.features || featureset);

        // If there are more objects to query, call this function again,
        // chaining the subsequent request's resolution to this promise;
        // otherwise, return the built features array
        i += layer.maxRecordCount;
        return i < len ? requestNext() : features;
    });
}

return requestNext();