ES6 Asynchrone verspricht

Question

Ich bin immer noch Anfänger in ES6. Ich versuche, eine Funktion zu erstellen, die eine http (s) -Anforderung mit der Logik sendet, die Sie senden, wenn Sie eine http (s) -Anfrage senden. Wenn 5 oder mehr laufende Anfragen vorhanden sind, müssen Sie warten, bis eine davon abgeschlossen ist, dann können Sie die nächste Anfrage bearbeiten. Wenn der Antwortcode nicht 200 ist, müssen Sie dreimal versuchen. Wenn der Antwortcode nach dreimal wiederholt nicht 200 ist, sollte die Fehlerfunktion ausgeführt werden. Ich möchte auch die JSON-Daten des Antwortkörpers als Funktionsargument erhalten.

function httpGet(url) { 
    return new Promise(
     function (resolve, reject) { 
      const request = new XMLHttpRequest(); 
      request.onload = function() { 
       if (this.status === 200) { 
        // Success 
        resolve(this.response); 
       } else { 
        // Something went wrong (404 etc.) 
        reject(new Error(this.statusText)); 
       } 
      }; 
      request.onerror = function() { 
       reject(new Error(
        'XMLHttpRequest Error: '+this.statusText)); 
      }; 
      request.open('GET', url); 
      request.send(); 
     }); 
} 

das was ich bisher gemacht habe. Dank

Answer 1

Hier ist eine allgemeine Warteschlange für Versprechen Rückrufe:

// Helper to run a callback when a promise either resolves, or rejects. 
function fin(promise, callback){ 
    return promise.then(
    value => (callback(), Promise.resolve(value)), 
    error => (callback(), Promise.reject(error)) 
); 
} 

function makeQueue(maxParallel){ 
    const queue = []; 
    let inProgress = 0; 

    // Run the oldest queued task. 
    function run(){ 
    const {resolve, reject, callback} = queue.shift(); 

    inProgress++; 
    return fin(callback(),() => inProgress--).then(resolve, reject); 
    } 

    // If more tasks can run in parallel, start them 
    function dequeue(){ 
    if (queue.length > 0 && inProgress < maxParallel) run().then(dequeue); 
    } 

    return function(callback){ 
    return new Promise((resolve, reject) => { 
     queue.push({resolve, reject, callback}); 
     dequeue(); 
    }); 
    } 
} 

dann die Warteschlange verwenden, um Warteschlange httpGet:

const queue = makeQueue(5); 

// Queue up httpGet calls. 
function httpGetWithQueue(url){ 
    return queue(() => httpGet(url)); 
} 

Dann rufen, dass mit Wiederholungslogik:

// Call httpGet with queued processing, with the request tried 
// up to three times. 
function httpGetWithRetry(url){ 
    let result = Promise.reject(); 

    for (var i = 0; i < 3; i++){ 
    result = result.catch(() => httpGetWithQueue(url)); 
    } 
    return result; 
}