Javascript 按旁路顺序执行HTTP请求

我想要实现的是同步执行一个有序的HTTP请求序列，但是根据一些变量的值，我希望其中一些被旁路

例如（我使用Javascript中的

request

库来执行此操作）：

因此，这确保了

httpReq2

将在

httpReq1

之后执行

我不确定的是，例如，如果某个标志设置为false，那么如何绕过第一个请求，而不是执行

httpReq1

并等待响应，而是跳到

httpReq2

，保持顺序：

if (dontMakeHttpReq1) // where should this be placed?

request(httpReq1, function(error, response, body) {
  // do something, like handling errors...
  request(httpReq2, function(error, response, body) {
    // do something else
  });
});

---

解决这个问题的好方法是什么？

您可以使用async Wait来实现这一点

async apiCall(){ 
    try{
     if(condition){
      const result1 = await request(httpReq1);
     }
     const result2 = await request(httpReq2);
    }
    catch(error){

    }
}

确保请求模块运行承诺。否则，创建一个承诺包装器。是一个基于承诺的图书馆

---

您必须将async放在包含等待的函数之前

您可以使用async await来实现这一点

async apiCall(){ 
    try{
     if(condition){
      const result1 = await request(httpReq1);
     }
     const result2 = await request(httpReq2);
    }
    catch(error){

    }
}

确保请求模块运行承诺。否则，创建一个承诺包装器。是一个基于承诺的图书馆

---

您必须将async放在包含等待的函数之前

为什么不使用2个条件

if (dontMakeHttpReq1) {
  request(req1, function(error, response, body) {
    yourRequestProcessing2();
  });
}
else {
  request(req1, function(error, response, body) {
    request(req2, function(error, response, body) {
      yourRequestProcessing2();
    });
    yourRequestProcessing1();
  });
}

编辑：可能您希望将请求调用存储在数组中

//Whether request n should skip
var flags = [
  false,
  true,
  false
];
var requests = [
  function(error, response, body) {
    //Process your request 1
  },
  function(error, response, body) {
    //Process your request 2
  },
  function(error, response, body) {
    //Process request 3
  }
];
for (i = 0; i < requests.length; i++) {
  if (flags[i]) {
    request(req1, requests[i + 1]);
  }
  else {
    request(req2, request[i]);
  }
}

//请求n是否应跳过
变量标志=[
假,，
是的，
假的
];
var请求=[
功能（错误、响应、正文）{
//处理您的请求1
},
功能（错误、响应、正文）{
//处理您的请求2
},
功能（错误、响应、正文）{
//处理请求3
}
];
对于（i=0；i

为什么不使用两个条件

if (dontMakeHttpReq1) {
  request(req1, function(error, response, body) {
    yourRequestProcessing2();
  });
}
else {
  request(req1, function(error, response, body) {
    request(req2, function(error, response, body) {
      yourRequestProcessing2();
    });
    yourRequestProcessing1();
  });
}

编辑：可能您希望将请求调用存储在数组中

//Whether request n should skip
var flags = [
  false,
  true,
  false
];
var requests = [
  function(error, response, body) {
    //Process your request 1
  },
  function(error, response, body) {
    //Process your request 2
  },
  function(error, response, body) {
    //Process request 3
  }
];
for (i = 0; i < requests.length; i++) {
  if (flags[i]) {
    request(req1, requests[i + 1]);
  }
  else {
    request(req2, request[i]);
  }
}

//请求n是否应跳过
变量标志=[
假,，
是的，
假的
];
var请求=[
功能（错误、响应、正文）{
//处理您的请求1
},
功能（错误、响应、正文）{
//处理您的请求2
},
功能（错误、响应、正文）{
//处理请求3
}
];
对于（i=0；i

对数组中需要的请求列表进行排序，并使用

async/await

let requests = [];
if (doRequest1)
  requests.push(httpReq1);

if (doRequest2)
  requests.push(httpReq2);

/* etc .. for httpReq3 and so on */

// now execute them one by one in sequence
for(let req of requests) {
   try {
     await request(req);
   } catch (err) {
     // error handling here
   }
}

---

整理数组中需要的请求列表，并使用

async/await

let requests = [];
if (doRequest1)
  requests.push(httpReq1);

if (doRequest2)
  requests.push(httpReq2);

/* etc .. for httpReq3 and so on */

// now execute them one by one in sequence
for(let req of requests) {
   try {
     await request(req);
   } catch (err) {
     // error handling here
   }
}

---

嘿，谢谢你的回答。我不喜欢这种方法，因为我有一系列的多个请求。所以我尽量避免重复代码。请求是否都基于他们以前的代码？没有像从请求3到请求2这样的跳跃？它们应该按顺序执行，并始终保持链中的请求数。嘿，谢谢你的回答。我不喜欢这种方法，因为我有一系列的多个请求。所以我尽量避免重复代码。请求是否都基于他们以前的代码？没有像从请求3到请求2这样的跳跃？它们应该按顺序执行，并始终保持链中的请求数。嘿，看起来不错。问题是，我只想根据某个变量的状态跳过第一个请求（理想情况下，主链中的任何请求）：您总是发出第一个请求。请检查编辑。只考虑等待调用作为同步语句。它们按顺序执行，并等待回调调用无问题。我只是好奇。嘿，看起来不错。问题是，我只想根据某个变量的状态跳过第一个请求（理想情况下，主链中的任何请求）：您总是发出第一个请求。请检查编辑。只考虑等待调用作为同步语句。它们按顺序执行，并等待回调调用无问题。我只是好奇。当然，这是一条路！当然，这是一条路！