Javascript 从2个单独的函数顺序链接承诺

我已经回顾了所有相关主题，但由于某种原因，我无法理解解决我的案例的正确语法。 它是Framework7平台上的Javascript

有一个函数的内部各有一个$。循环遍历一个项目数组，并执行一个异步POST操作来更新该项目。 需要在两个不同的位置更新项，因此我执行了两次此函数，每次使用不同的参数

当所有异步请求都已执行时，将这两个函数按顺序链接在一起以重新加载页面的最佳方法是什么

提前谢谢你

更新

我成功地做到了这一点，但承诺不会带来“成功”：

更新2-根据建议更改代码

var processtasks = function(array, dig) {
   var getlistname = GetItemTypeForListName("Alerts")
   var itemProperties = {'Title' :"Test"};
   var UpdatePayload = {'__metadata': {'type': getlistname}};
   for(var prop in itemProperties){
      UpdatePayload[prop] = itemProperties[prop]
   }
   var buildurl = "<REST URL to Sharepoint list>"
   var buildheader = { "Accept": "application/json;odata=verbose", "X-RequestDigest" : dig, "X-HTTP-Method": "MERGE", "If-Match": "*"}
   return Promise.all(array.map(function(item) {
      buildurlnew = buildurl+"("+item+")";
      return app.request({
         url: buildurlnew,
         type: "POST",
         headers: buildheader,
         contentType: "application/json;odata=verbose",
         data: JSON.stringify(UpdatePayload),
         success: function (data) {},
         error: function(xhr, textStatus, errorThrown) {}
      });
   }));
}

var processitems = function(listName, array, dig, type, source, web) {
   var getlistname = GetItemTypeForListName(listName)
   var buildurl = "<REST URL to Sharepoint list>"
   var buildheader = { "Accept": "application/json;odata=verbose", "X-RequestDigest" : dig, "If-Match": "*"}
   return Promise.all(array.map(function(item) {
      var itemProperties = {'UserId' : app.data.UserID, 'Title' : item};
      var UpdatePayload = {'__metadata': {'type': getlistname}};
      for(var prop in itemProperties){
         UpdatePayload[prop] = itemProperties[prop]
      }
      return app.request({
          url: buildurl,
          type: "POST",
          headers: buildheader,
          contentType: "application/json;odata=verbose",
          data: JSON.stringify(UpdatePayload),
          success: function (data) {},
          error: function(xhr, textStatus, errorThrown ) {}
      });
   }));
}

processitems(listName, array, dig, type, source, web).then(function(r1) {
   return processtasks(ids,dig);
}).then(function(r2) {
   console.log(r2);
}).catch(function(err) {
   console.log(err);
});

var processtasks=函数（数组，dig）{
var getlistname=GetItemTypeForListName（“警报”）
var itemProperties={'Title'：“Test”}；
var UpdatePayload={''uu元数据'：{'type'：getlistname}；
for（itemProperties中的var prop）{
UpdatePayload[prop]=itemProperties[prop]
}
var buildurl=“”
var buildheader={“Accept”：“application/json；odata=verbose”，“X-RequestDigest”：dig，“X-HTTP-Method”：“MERGE”，“If Match”：“*”}
返回Promise.all（array.map）（函数（项）{
buildurlnew=buildurl+”（“+item+”）；
返回app.request({
url:buildurlnew，
类型：“POST”，
标题：buildheader，
contentType:“application/json；odata=verbose”，
数据：JSON.stringify（UpdatePayload），
成功：函数（数据）{}，
错误：函数（xhr、textStatus、errorshown）{}
});
}));
}
var processitems=函数（列表名、数组、数据挖掘、类型、源、web）{
var getlistname=GetItemTypeForListName（listName）
var buildurl=“”
var buildheader={“Accept”：“application/json；odata=verbose”，“X-RequestDigest”：dig，“If Match”：“*”}
返回Promise.all（array.map）（函数（项）{
var itemProperties={'UserId'：app.data.UserId，'Title'：item}；
var UpdatePayload={''uu元数据'：{'type'：getlistname}；
for（itemProperties中的var prop）{
UpdatePayload[prop]=itemProperties[prop]
}
返回app.request({
url:buildurl，
类型：“POST”，
标题：buildheader，
contentType:“application/json；odata=verbose”，
数据：JSON.stringify（UpdatePayload），
成功：函数（数据）{}，
错误：函数（xhr、textStatus、errorshown）{}
});
}));
}
processitems（列表名、数组、数据挖掘、类型、源、web）{
返回进程任务（ID、dig）；
}).然后（功能（r2）{
控制台日志（r2）；
}).catch（函数（err）{
控制台日志（err）；
});

首先，您必须修复

asyncOperation（）

函数，因为它没有正确返回连接到您正在执行的底层异步操作的承诺

这段代码没有多大意义。你有一个这样的基本结构：

var asyncOperation = function(items) {
    return new Promise(function(resolve, reject) {
        // body of function here
    });
}

到目前为止还不错。但是，在promise executor函数中需要做的是启动一些异步操作，并在完成后调用resolve或reject。你没有那样做。因此，你的承诺永远不会改变或拒绝

相反，您将从promise executor回调返回一个延迟数组，该回调不做任何操作。promise executor函数不期望任何返回值，因此从中返回值不会产生任何效果。您必须通过调用

resolve（…）

或

reject（…）

来指示promise executor中异步操作的完成

如果

app.request（）

返回一个承诺，那么您甚至不需要做出自己的承诺。你可以这样做：

var asyncOperation = function(items) {
    return Promise.all(items.map(function(item) {
        return app.request(...);
    }));
}

asyncOperation(...).then(function(results) {
    // all done here
}).catch(function(err) {
    // error here
});

items.map（）


如果
app.request（）
没有返回承诺，那么您可能应该制作一个“promisified”版本，这样您就可以将它与承诺函数一起使用，比如
promise.all（）
，可能使用
util.promisify（）


要并行运行其中两个（这似乎是可行的，因为它们似乎并不相互依赖），可以执行以下操作：

然后，在正确返回函数的承诺后，如果您有其中两个，您可以在多个函数调用中使用
promise.all（）
：

Promise.all([asyncOperation(...), asyncOperation(...)]).then(function(results) {
    // both done here
    // not the result may be an array of arrays
}).catch(function(err) {
    // error here
});


将这两个功能按顺序链接在一起的最佳方法是什么

要按顺序运行它们，可以执行以下操作：

asyncOperation(args1).then(function(r1) {
    return asyncOperation(args2);
}).then(function(r2) {
    console.log(r2);
}).catch(function(err) {
    console.log(err);
});

一种编程语言和您正在开发的框架/平台在这里很有用：如果它们可以同时运行：
Promise.all（[p1，p2]）
。如果一个接一个发生：
p1。然后（p2）
。我道歉。我在Framework7平台上使用Javascript工作（“尝试工作”实际上更准确地表示我的职位）。你的
新承诺
函数从不在你创建的承诺数组中使用
解析
或
拒绝
。你可以从那里开始思考。然而，您可能甚至不需要承诺构造函数。只需返回
Promise.all（延迟）
。所以你可能会喜欢
asyncOperation（firstItems）。然后（resultsArray=>（doSomethingWith（resultsArray），asyncOperation（secondItems））。然后（doSomethingWith）
某种程度上。我现在很困惑的是，是如何从所有这些函数中得到单个解析。每个函数内的每个迭代？添加了有关处理其中两个函数调用的更多信息。根据您的建议重写app.request函数。创建了两个单独的app.request函数，因为它们都可以在
asyncOperation(args1).then(function(r1) {
    return asyncOperation(args2);
}).then(function(r2) {
    console.log(r2);
}).catch(function(err) {
    console.log(err);
});