Schleife durch mehrere Versprechen effizient

Question

Ich bin neu bei Node.js und asynchronen Aufrufen, aber ich versuche ein Programm zu erstellen, das automatisch mehrere Transaktionen vornehmen kann. Die Sache ist, gerade stelle ich zuerst eine Verbindung zu Hyperledger Fabric her und führe dann die Funktion durch eine for-Schleife aus.

Das ist ziemlich schnell, aber ich freue mich auf die Geschwindigkeit zu verbessern. Dies ist der Code, den die Verbindung initiiert:

init() { 
     return this.businessNetworkConnection.connect(this.connectionProfile, this.businessNetworkIdentifier, participantId, participantPwd) 
      .then((result) => { 
       console.log(chalk.green('Connected to Hyperledger!')); 
       this.businessNetworkDefinition = result; 
      }) 
      .catch(function (error) { 
       console.log('An error occured: ', chalk.bold.red(error)); 
      }); 
    } 

Dies ist der Code, den ich Transaktionen auf dem Hauptbuch machen kann:

makeTransaction(fromID, toID, funds) { 
     const METHOD = 'makeTransaction'; 
     let from; 
     let walletRegistry; 
     let to; 

     return this.businessNetworkConnection.getAssetRegistry('org.acme.Wallet') 
      .then((registry) => { 
       console.log(1); 
       walletRegistry = registry; 
       return walletRegistry.get(fromID); 
      }) 
      .then((fromm) => { 
       console.log(2); 
       from = fromm; 
       return walletRegistry.get(toID); 
      }) 
      .then((too) => { 
       to = too; 
      }) 
      .then(() => { 
       let serializer = this.businessNetworkDefinition.getSerializer(); 
       let resource = serializer.fromJSON({ 
        "$class": "org.acme.Transfer", 
        "amount": funds, 
        "from": { 
         "$class": "org.acme.Wallet", 
         "id": from.getIdentifier(), 
         "balance": from.balance, 
         "owner": "resource:org.acme.Client#" + from.owner.getIdentifier() 
        }, 
        "to": { 
         "$class": "org.acme.Wallet", 
         "id": to.getIdentifier(), 
         "balance": to.balance, 
         "owner": "resource:org.acme.Client#" + to.owner.getIdentifier() 
        } 
       }); 

       return this.businessNetworkConnection.submitTransaction(resource); 
      }) 
      .catch(function (error) { 
       throw (error); 
      }) 
    } 

Aber die Funktion, die jetzt die Transaktion wie folgt geschehen Aussehen macht .

static transfer(fromID, toID, funds) { 
     let bm = new BlockchainManager(); 
     return bm.init() 
      .then(() => { 
       return bm.makeTransaction(fromID, toID, funds); 
      }) 
      .then(() => { 
       console.log('Success!'); 
      }) 
      .catch(function (error) { 
       console.log('An error occured: ', chalk.bold.red(error)); 
       process.exit(1); 
      }); 
    } 

Ich glaube nicht, dies der beste Weg ist, eine Menge von Transaktionen zu machen (ich bin auf der Suche mehr als 1000 pro Sekunde zu einem bestimmten Zeitpunkt laufen). Was wäre der beste Weg dies zu programmieren?

Answer 1

können Sie tun.

let all_promise = []; 
/* 
* your loop here 
* for(let i = 0; i < am ; I++){ 
* all_promise.push(transfer(i,i+1,i*29); 
* } 
*/ 
Promise.all(all_promise).then(arr => { 
     // arr is the map arr of all the promises that "transfer()" method returned 
     // you can Iterate the arr since its the resolve value of all the promises that was push from all_promise . you need to refactor big time in your code. 
}) 

ich kommentieren Sie einfach die for-Schleife für Sie eine Idee haben .. die Idee dafür ist Sie alle Versprechen schieben, die noch nicht in ein Array lösen dann das Array übergeben an die Promise.all die dann Teil ist das Array der Auflösungswerte

Answer 2

Haben Sie versucht, Promise.all zu verwenden? Ich denke, ist Werke wie:

Promise.all([asyncFunc1(), asyncFunc2(), asyncFunc3(),... ]) 
.then(function(result){...}) 
.catch(function(error){...}); 

Die .then() aufgerufen wird, wenn alle Versprechungen wurden gelöst.