So implementieren Sie die Ajax-Kontrolle gleichzeitiger Anforderungen basierend auf JS

    const delay = Funktion Verzögerung(Intervall) {
      gib ein neues Promise zurück((res,rej) => {
        setzeTimeout(() => {
          res(Intervall)
        }, Intervall);
      })
    }


    let Aufgaben = [() => {
      Rückgabeverzögerung (1000)
    },() => {
      Rückgabeverzögerung(1003)
    },() => {
      Rückgabeverzögerung(1005)
    },() => {
      Rückgabeverzögerung(1002)
    },() => {
      Rückgabeverzögerung(1004)
    },() => {
      Rückgabeverzögerung(1006)
    }]

    // Parallelität durch Promise.all implementieren Promise.all(tasks.map(task => task())).then(res => {
      konsole.log(res);
    })

    // Implementiere die Funktion creatRequest(tasks,pool) basierend auf Promise {
      // Die Anzahl der jeweils gesendeten Anfragen wird vom Pool gesteuert
      Pool = Pool || 5
      // Wird zum Speichern der Ergebnisse jeder Anfrage verwendet (in der richtigen Reihenfolge gespeichert)
      lass Ergebnisse = [],
      // together wird verwendet, um Arbeitsbereiche zu erstellen. Wenn pool übergeben wird, erstellen wir entsprechend mehrere Arbeitsbereiche. // Das heißt, wir erstellen ein Array mit der Länge von pool und dem Wert null together = new Array(pool).fill(null),
      // Index ist der Taskwert, der jedes Mal erhalten wird. Index = 0;
      zusammen = zusammen.map(() => {
        // Verwaltung basierend auf Promise return new Promise((resolve,reject) => {
          // Eine Funktion erstellen und sofort ausführen const run = function run() {
            // Wenn der Taskpool leer ist, bedeutet dies, dass die Anfrage erfolgreich gesendet wurde, if(index >= tasks.length) {
              lösen()
              zurückkehren 
            }
            // Speichern Sie zuerst den Index, um das Ergebnis der aktuellen erfolgreichen Anforderung zu speichern. let old_index = index,
            // Die aktuell gesendete Anfrage abrufen und dann den Index akkumulieren, sodass der Index oben gespeichert wird // ​​Hier wird zuerst index++ berechnet und dann akkumuliert, während ++index das Gegenteil ist, zuerst akkumulieren und dann berechnen task = tasks[index++];
            // Anforderung ausführen task().then(result => {
            // Speichere das erfolgreiche Ergebnis results[old_index] = result
            // Rekursiv mit der Ausführung fortfahren, d. h. die Aufgabe weiterhin in den Arbeitsbereich bringen, um sie auszuführen. run();
            }).catch(Grund => {
              ablehnen (Grund)
            })
          }
          // Führe run() sofort aus
        })
      })
      //Verwenden Sie Promise.all, um den Arbeitsbereich zu steuern, d. h. stellen Sie zwei Anfragen gleichzeitig. return Promise.all(together).then(() => results)
    }


    creatRequest(Aufgaben,2).dann(Ergebnisse => {
      // Alles muss erfolgreich sein, damit das Ganze erfolgreich ist. Speichern Sie die Ergebnisse der Reihe nach. console.log('success',results);
    }).catch(auflösen => {
      // Wenn nur einer von ihnen ausfällt, fällt das ganze System aus console.log('failed');
    })



    // Implementiere die Funktion creatRequest(tasks,pool,callback) basierend auf Klasse {
      // Parametereinschränkung und -überprüfung if(typeof pool === 'function') {
        Rückruf = Pool;
        Pool = 5
      }
      wenn (Pooltyp !== 'Zahl') Pool = 5
      wenn (Typ des Rückrufs !== 'Funktion') Rückruf = Funktion () {}
      //------
      Klasse TaskQueue {
        // Anzahl der laufenden Läufe = 0;
        // Alle Aufgaben in der Warteschlange = [] in die Warteschlange stellen;
        //Speichern Sie die Ergebnisse der Aufgabenausführung (Anfragen). results = [];
        pushTask(Aufgabe) {
          lass selbst = dies
          // Aufgabe in den Arbeitsbereich verschieben self.queue.push(task)
          // Führe die Logik zum Senden der Anfrage aus self.next()
        }
        nächste() {
          lass selbst = dies
          // Wenn die Anzahl der ausgeführten Aufgaben geringer ist als die Parallelität, weiterhin Aufgaben zur Ausführung übernehmen while(self.runing < pool && self.queue.length) {
            selbst.läuft++;
            // Dies entspricht dem Übernehmen und Löschen einer Aufgabe. let task = self.queue.shift();
            // Anforderung ausführen task().then(result => {
              //Speichern Sie die Ausführungsergebnisse self.results.push(result)
            }).schließlich(() => {
              //Anzahl der laufenden Elemente löschen self.runing--
              // Mit der Ausführung der Anfrage fortfahren self.next()
            })
          }
          // Wenn keine Aufgaben vorhanden sind, endet die Schleife if(self.runing === 0) callback(self.results)
        }


      }
      // Instanziierung let TQ = new TaskQueue()
      Aufgaben.fürJeden(Aufgabe => TQ.pushTask(Aufgabe))
    }


    creatRequest(Aufgaben,2,Ergebnisse=> {
      console.log(Ergebnisse);
    })