Javascript 如何调用数千个AJAX嵌套GET请求？

我需要执行数千个AJAX GET请求——由于它们的依赖关系，它们需要嵌套（这意味着：下一个AJAX请求使用来自前一个请求响应的变量）

通过下面的例子，我尽可能多次地请求，但在这种情况下，我需要做上千次，所以不可能这样写

我试图用多种方式编写循环，但它们都导致了一种非预期的行为

$.ajax({
        url: 'urllink.com',
        beforeSend: function(xhr) {
             xhr.setRequestHeader("Accept", "application/json")
        }, success: function(responseJSON){

            var jsonResponse = Object.values(responseJSON).pop()
            alert(jsonResponse);


$.ajax({
        url: 'urllink.com'+jsonResponse,
        beforeSend: function(xhr) {
             xhr.setRequestHeader("Accept", "application/json")
        }, success: function(responseJSON){

            var jsonResponse = Object.values(responseJSON).pop()
            alert(jsonResponse);

           

        }


})
        }


}) 

---

您可以创建一个函数来调用

ajax

和另一个函数来调用循环中的第一个函数，然后在每次迭代中传递result参数

 function calls(val){
  var   res=$.ajax({
    url: 'urllink.com'+val,
    beforeSend: function(xhr) {
         xhr.setRequestHeader("Accept", "application/json")
    }, success: function(responseJSON){
  
        return Object.values(responseJSON).pop()
    }
 }).responseText
 return res
}
var val="intialvalue"
async function makecalls(){
  for (let i=0;i<1000;i++){
    var param= await calls(val)
           val=param
  }
}

函数调用（val）{
var res=$.ajax({
url:'urlink.com'+val，
发送前：函数（xhr）{
setRequestHeader（“接受”、“应用程序/json”）
}，success:function（responseJSON）{
返回Object.values（responseJSON.pop（））
}
}).responseText
返回res
}
var val=“初始值”
异步函数makecalls（）{
对于（设i=0；i
let count=0；
功能请求（url、金额）{
让回忆=this.req；
$.ajax({
url:`${url}`，
发送前：函数（xhr）{
setRequestHeader（“接受”、“应用程序/json”）
},
成功：功能（responseJSON）{
var jsonResponse=Object.values（responseJSON.pop（））
警报（JSON.stringify（jsonResponse））；
计数++
如果（金额>计数）{
召回（url、金额）；
}
}
});
};
请求（'urlink.com'，2）；

我所做的是创建一个
调用
变量，该变量使用相同的参数运行自身，然后检查
计数是否执行自身。
考虑如下支架。每个异步请求将并发运行，并在完成后生成自己的替换。详细信息留作练习

let i = 1000;

function doRequest() {
    // some state advancement and termination condition
    // this can include the “target url” which can be supplied
    // as a parameter (eg. function doRequest(url)): adjust accordingly.
    if (i <= 0)
        return;
    i = i - 1;
    let x = i;
    console.log(x + “ starting”);

    $.ajax({
        ...,
        success: function () {
             // don’t use alert here! >_<
             console.log(x + “ done”);
             // function has access to it’s own name
             // (this is a form of “stack less” recursion)
             // start the next asynchronous call!
             // tip: pass some “next url” result data for this problem
             doRequest();
        }
        // also handle failure case
    );
}

设i=1000；
函数doRequest（）{
//某些状态的提前和终止条件
//这可以包括可以提供的“目标url”
//作为参数（例如函数doRequest（url））：相应地调整。
如果（i）_<
控制台日志（x+“完成”）；
//函数可以访问它自己的名称
//（这是“无堆栈”递归的一种形式）
//开始下一个异步调用！
//提示：为此问题传递一些“下一个url”结果数据
doRequest（）；
}
//同时处理故障案例
);
}

对于独立的子问题，并发的自替换请求可以并行启动N次。浏览器一次只能启动几个并行请求（例如，2..8是常见的，远远少于数百个）。远程服务器的并行能力可能更低

// example only, call once with “start url” for this task
// as the specific problem establishes a data dependency
// and the requests cannot be run in parallel
// unless there is a method to divide the problem
for (let n = 0; n < 8; n++) {
    doRequest();
}

//仅举一个例子，使用“启动url”为此任务调用一次
//因为特定问题建立了数据依赖关系
//请求不能并行运行
//除非有办法解决这个问题
for（设n=0；n<8；n++）{
doRequest（）；
}

免费输入，iPhone让这变得很难：（
假设所有请求都按顺序在响应对象中提供一个
next
属性，直到最后一个没有该属性（或其值返回falsy）的请求，您应该能够使用以下递归承诺链

最终结果将是返回的所有
next
值的数组

const  getData = (path, results=[]) => {
   let url = 'urllink.com' + (path || '');
   // return an ajax promise 
   return $.getJSON(url).then(({next}) => {
       if(next){
         // store current value in results array
         results.push(next);
         // return another request promise
         return getData(next, results); 
       } else {
         // when run out of nexts return the array of data to the final then()
         return results;
       }
   });
}

用法：

getData().then(data => console.log(data))// array of all the `next` values received
         .catch(err => console.log('Ooops, one of the requests failed'));

听起来您希望将ajax调用放入函数中并递归调用。您是否尝试DDOS服务器？如果可能，我会考虑创建一个后端脚本来执行递归工作，并向该脚本发送尽可能少的ajax请求，让它编译结果并将其发送回。使用回调“递归地”当XHR进程完成时，再次调用函数，确保处理错误结果并添加一些终止条件。考虑函数定义为：函数MAKECALL（…）{…}，然后在函数$中使用Ajax，成功/错误回调将调用MAKECALL再次玷污。（函数可以在其内部使用自己的名称）。顶级代码本身可以启动N个makeCall，这大致相当于N个并行请求流（受其他因素限制）。好的，第一个请求是根文件夹…然后你需要遍历所有请求每个文件夹的人，以返回其内容。然后遍历每个文件夹，直到有和结束。显示的解决方案中没有一个是为此设置的。此外，还不清楚如何确定结束或示例数据的外观。我也假设您是否希望构建一个类似于文件夹结构的数据树，但这一点还不清楚。如果您使用的是
async
/
wait
，则根本不应该传递
success
回调。此外，也没有理由将其放入单独的函数中，它也可以内联工作。对，返回
success
是u没有自我，在任何地方都不会被抓住，也不会被传给承诺chain@Begi我正在将上一个调用的值传递到下一个调用，因为下一个调用依赖于第一个调用。这就是为什么，但无论如何，我注意到，您似乎所做的一切都是在没有正当理由的情况下对我进行下一次投票。除了增加全局
计数
，您应该只减少t命名函数“req”中的本地
amount
，“req”是指函数的绑定变量。不需要调用变量或“this.req”（上下文中实际上是“window.req”）。