Wie diese asynchrone Funktion synchron machen

Question

ich die folgende Funktion aufrufe:

function uploadReturns() { 
    var uploads = me.getIssuesFromReturnsList(); 
    uploadreturnsobjects(uploads); //process the uploads object and send it to an AJAX call 

} 

In me.getIssuesFromReturnsList die uploadList Variable zurückgegeben werden, bevor der Rest des Code ausführt, weil es asynchron ist (gemäß this question)

me.getIssuesFromReturnsList = function() { 
    var uploadList = []; 
    $.each(me.returnsList(), function (index, i) { 
     var issue = issueRepository.GetDefaultIssue(); 
     issue.barcode = i.barcode; 
     issue.ReturnsAmount(i.amount); 

     var uploadItem = { 
      barcode: i.barcode, 
      amount: i.amount, 
      issue: ko.observable(issue) 
     }; 

     uploadList.push(uploadItem); 

     issueRepository.GetIssuesOffline(i.barcode, function (issues) { 
      if (issues.length > 0) { 
       uploadItem.issue(issues[0]); 
      } 
     }); 
    }); 

    return uploadList; 
} 

Wie kann ich diesen Code ändern, sodass die Aufrufe nicht mehr asynchron sind und stattdessen auf die Ausführung des gesamten inneren Codes warten, bevor die uploadList zurückgegeben wird?

Answer 1

mit Versprechungen:

function forEachChain (array, func, thisArg) { 
    const res = []; 

    function exec(resolve, i) { 
     func.call(thisArg, array[i]).then((e) => { 
      res[i] = e; 
      if (i < array.length - 1) { 
       exec(resolve, i + 1); 
      } else { 
       resolve(res); 
      } 
     }, (err) => { 
      res[i] = err; 
      if (i < array.length - 1) { 
       exec(resolve, i + 1); 
      } else { 
       resolve(res); 
      } 
     }); 
    } 

    return new Promise((resolve) => { 
     if (array.length > 0) { 
      exec(resolve, 0); 
     } else { 
      resolve([]); 
     } 
    }); 
} 

jetzt können Sie diese Funktion aufrufen ein Array übergeben. für jedes Element dieses Arrays func heißt (von Ihnen übergeben) unter der Annahme, dass es auch eine Promise zurückgibt.

Die asynchronen Aufrufe werden eine pro Zeit aufgerufen (die gleichzeitige Version ist ein bisschen komplizierter).

Im Falle von Fehlern enthält das Array den relativen Fehler am relativen Index.

forEachChain(myArray, myFuncReturningAPromise, thisArgInsideEachFuncCall).then((arrOfSameSizeOfMyArray) => { 
    // myCallback 
}