Ausbeute nicht aufgelöst Versprechen node.js

Question

Ich habe den folgenden Code und obwohl in diesem Beispiel nichts asynchron ist habe ich es geschrieben, um den Fluss mit Generatoren und Versprechungen zu verstehen.

Mein Ziel ist es, durch das Array zu durchlaufen und einen asynchronen Prozess für jedes einzelne Element im Array auszuführen, und ich möchte es in der Reihenfolge tun. Von dem, was ich gelesen habe, erwartete ich, dass der yield operator(rule); den Wert der aufgelösten Versprechen ergeben würde. Anstelle des Wertes false gibt es mir ein Promise wie das folgende Promise { false }

Ich denke, dass ich etwas wichtiges in diesem Fluss vermisse/missverstand.

Hier ist der Code:

'use strict'; 

let operator = function (rule) { 
    return new Promise((resolve, reject) => { 
     resolve(rule.bool); 
    }); 
}; 

let setOfRule = [ 
    { 
     name: 'one', 
     bool: false 
    }, 
    { 
     name: 'two', 
     bool: false 
    }, 
    { 
     name: 'three', 
     bool: false 
    } 
]; 

let myGen = function* (rules) { 
    for (let rule of rules) { 
     try { 
      yield operator(rule); 
     } catch (e) { 
      console.log(e); 
     } 
    } 
}; 

for (let filtered of myGen(setOfRule)) { 
    console.log(filtered); // Promise { false } 
    console.log(`Is it filtered: ${filtered}`); // Is it filtered: [object Object] 

    if (filtered) { 
     break; 
    } 
} 

Answer 1

ich diesen schönen Artikel und ein schönes Stück Code hier http://www.html5rocks.com/en/tutorials/es6/promises/

Anstatt zu versuchen, zu durchlaufen meinen Generator X-mal und holen den Wert gefunden. Ich wiederhole die Werte und erziele das Versprechen in jeder Iteration. Das on löst das Versprechen mit der nächsten Methode meines iterable auf, andernfalls wird es mit einem throw-Fehler abgelehnt.

Hier ist der Arbeitscode:

'use strict'; 

let operator = function (rule) { 
    return new Promise((resolve, reject) => { 
     resolve(rule.bool); 
    }); 
}; 

let setOfRule = [ 
    { 
     name: 'one', 
     bool: false 
    }, 
    { 
     name: 'two', 
     bool: false 
    }, 
    { 
     name: 'three', 
     bool: false 
    } 
]; 

let spawn = function spawn(generatorFunc) { 
    function continuer(verb, arg) { 
     let result; 
     try { 
      result = generator[verb](arg); 
     } catch (err) { 
      return Promise.reject(err); 
     } 

     if (result.done) { 
      return result.value; 
     } else { 
      return Promise.resolve(result.value).then(onFulfilled, onRejected); 
     } 
    } 

    let generator = generatorFunc(); 
    let onFulfilled = continuer.bind(continuer, 'next'); 
    let onRejected = continuer.bind(continuer, 'throw'); 

    return onFulfilled(); 
} 

spawn(function *() { 
    try { 
     for (let rule of setOfRule) { 
      let something = yield operator(rule); 

      console.log(something); 
     } 

     console.log('Done!!!!'); 
    } catch (err) { 
     console.log('Error: ', err); 
    } 
});