Attendre un événement pour résoudre une promesse

Question

J'utilise un module node.js qui a une méthode sans callbacks. Au lieu de cela, a un événement qui se déclenche lorsque cette méthode est terminée. Je veux résoudre une promesse, en utilisant cet événement comme rappel me sécurisant cette méthode a été achevée avec succès. Array.lenght sur promesse peut être X. Donc, j'ai besoin d'entendre x fois l'événement pour me garantir que toutes les méthodes ont terminé avec succès < - Ce n'est pas le problème, je vous dis juste que je savoir cela pourrait se produire

événement:

tf2.on('craftingComplete', function(recipe, itemsGained){ 
    if(recipe == -1){ 
    console.log('CRAFT FAILED') 
    } 
    else{ 
     countOfCraft++; 
    console.log('Craft completed! Got a new Item #'+itemsGained); 
    } 
}) 

Promise:

const craftWepsByClass = function(array, heroClass){ 
     return new Promise(function (resolve, reject){ 

      if(array.length < 2){ 
       console.log('Done crafting weps of '+heroClass); 
       return resolve(); 
      } 
      else{ 
       for (var i = 0; i < array.length; i+=2) { 
        tf2.craft([array[i].id, array[i+1].id]); // <--- this is the module method witouth callback 
       } 
     return resolve(); // <---- I want resolve this, when all tf2.craft() has been completed. I need 'hear' event many times as array.length 
      } 

     }) 
} 

Answer 1

Dans un premier temps permet promisify le craft:

function craft(elem){ 
//do whatever 
return Promise((resolve,reject) => 
    tf2.on('craftingComplete', (recipe,itemsGained) => 
    if(recipe !== -1){ 
    resolve(recipe, itemsGained); 
    }else{ 
    reject("unsuccessful"); 
    } 
    }) 
); 
} 

donc à des multiples d'artisanat puis, nous comparons nos promesses et tableau à utiliser Promise.all:

Promise.all(array.map(craft)) 
.then(_=>"all done!") 

Answer 2

Je dois vérifier si l'événement 'craftingComplete' a tiré plusieurs fois que je l'appelle tf2.craft. N'importe pas d'ID posible ou si l'engin a échoué. Je besoin de savoir si tf2.craft a fini et pourquoi ne vérifie événement « craftingComplete »

Étant donné que nous savons i au sein de la boucle for sera incrémenté i += 2 où i est inférieur à .length de array, nous pouvons créer une variable égale à ce nombre avant la boucle for et comparer i au nombre dans les gestionnaire d'événements

const craftWepsByClass = function(array, heroClass) { 
    return new Promise(function(resolve, reject) { 

    var countCraft = 0; 
    var j = 0; 
    var n = 0; 
    for (; n < array.length; n += 2); 

    tf2.on('craftingComplete', function(recipe, itemsGained) { 
     if (recipe == -1) { 
     console.log('CRAFT FAILED') 
     } else { 
     countOfCraft++; 
     console.log('Craft completed! Got a new Item #' + itemsGained); 
     if (j === n) { 
      resolve(["complete", craftCount]) 
     } 
     } 
    }) 

    if (array.length < 2) { 
     console.log('Done crafting weps of ' + heroClass); 
     return resolve(); 
    } else { 
     try { 
     for (var i = 0; i < array.length; i += 2, j += 2) { 
      tf2.craft([array[i].id, array[i + 1].id]); 
     } 
     } catch (err) { 
     console.error("catch", err); 
     throw err 
     } 
    } 

    }) 
} 

craftWepsByClass(array, heroClass) 
.then(function(data) { 
    console.log(data[0], data[1]) 
}) 
.catch(function(err) { 
    console.error(".catch", err) 
}) 

Answer 3

Si les événements seront tirés dans le même un ordre s les appels craft() respectifs qui les ont amenés, vous pouvez utiliser une file d'attente:

var queue = []; // for the tf2 instance 
function getNextTf2Event() { 
    return new Promise(resolve => { 
    queue.push(resolve); 
    }); 
} 
tf2.on('craftingComplete', function(recipe, itemsGained) { 
    var resolve = queue.shift(); 
    if (recipe == -1) { 
    resolve(Promise.reject(new Error('CRAFT FAILED'))); 
    } else { 
    resolve(itemsGained); 
    } 
}); 

function craftWepsByClass(array, heroClass) { 
    var promises = []; 
    for (var i = 1; i < array.length; i += 2) { 
    promises.push(getNextTf2Event().then(itemsGained => { 
     console.log('Craft completed! Got a new Item #'+itemsGained); 
     // return itemsGained; 
    })); 
    tf2.craft([array[i-1].id, array[i].id]); 
    } 
    return Promise.all(promises).then(allItemsGained => { 
    console.log('Done crafting weps of '+heroClass); 
    return …; 
    }); 
} 

Si vous ne savez pas quoi que ce soit sur l'ordre des événements, et il peut y avoir plusieurs appels simultanés à craftWepsByClass, vous ne pouvez pas éviter compteur global (ie un lié à l'instance tf2). L'inconvénient est que, par exemple. dans deux appels qui se chevauchent, la promesse a ne sera pas résolue avant la fin de l'élaboration du second appel.

var waiting = []; // for the tf2 instance 
var runningCraftings = 0; 
tf2.on('craftingComplete', function(recipe, itemsGained) { 
    if (--runningCraftings == 0) { 
    for (var resolve of waiting) { 
     resolve(); 
    } 
    waiting.length = 0; 
    } 
    if (recipe == -1) { 
    console.log('CRAFT FAILED') 
    } else { 
    console.log('Craft completed! Got a new Item #'+itemsGained); 
    } 
}); 

function craftWepsByClass(array, heroClass) { 
    for (var i = 1; i < array.length; i += 2) { 
    runningCraftings++; 
    tf2.craft([array[i-1].id, array[i].id]); 
    } 
    return (runningCraftings == 0 
    ? Promise.resolve() 
    : new Promise(resolve => { 
     waiting.push(resolve); 
     }) 
).then(() => { 
    console.log('Done crafting weps of '+heroClass); 
    }); 
} 

Bien sûr, dans les deux solutions, vous devez être certain à 100% que chaque appel à craft() cause exactement un événement.