如何等待承諾的在Javascript ECMAScript2015（ES6）

Question

相當新的ES6和好奇，想知道一個全產業鏈的完成目前是否有承諾，我可以future.wait()

我有一個名爲​​方法做了，這啓動了一系列的承諾。我有這個方法的兩個要求：

• 每一個承諾，當最後一個願望已經完成了應該只啓動（這部分我已經實現）
• ​​時承諾的整個鏈條已經執行完畢應僅返回（即我想阻止，直到最後的承諾是完整的）

這裏是我的示例代碼：

/* Require dependencies */ 
require('babel/polyfill'); 

class PromiseWaiter { 
    /* Constructor */ 
    constructor() { 
    } 

    /* Methods */ 
    execute() { 
    let _this = this; 

    runPromiseGenerator(function *promiseGenerator() { 
     yield _this.asyncMethod1(); 
     yield _this.asyncMethod2(); 
     yield _this.asyncMethod3(); 
    }); 

    return true; 
    } 

    asyncMethod1() { 
    return returnDummyPromise('method 1', 800); 
    } 
    asyncMethod2() { 
    return returnDummyPromise('method 2', 200); 
    } 
    asyncMethod3() { 
    return returnDummyPromise('method 3', 200); 
    } 
} 

var runPromiseGenerator = function(generator) { 
    var it = generator(), ret; 

    // asynchronously iterate over generator 
    (function iterate(val) { 
    ret = it.next(val); 

    if (!ret.done) { 
     // poor man's "is it a promise?" test 
     if ("then" in ret.value) { 
     // wait on the promise 
     ret.value.then(iterate); 
     } 
     // immediate value: just send right back in 
     else { 
     // avoid synchronous recursion 
     setTimeout(function(){ 
      iterate(ret.value); 
     }, 0); 
     } 
    } 
    })(); 

}; 

var returnDummyPromise = function(methodName, timeout) { 
    console.log('starting %s', methodName); 
    return new Promise(function(resolve, reject) { 
    setTimeout(function() { 
     console.log('finished %s', methodName); 
     resolve(); 
    }, timeout); 
    }) 
}; 

module.exports = PromiseWaiter; 

這裏是我的在節點控制檯上運行測試&電流輸出：

> p = new PromiseWaiter() 
{} 
> p.execute() 
starting method 1 
true 
> finished method 1 
starting method 2 
finished method 2 
starting method 3 
finished method 3 

我想看到的是：

> p = new PromiseWaiter() 
{} 
> p.execute() 
starting method 1 
finished method 1 
starting method 2 
finished method 2 
starting method 3 
finished method 3 
true 
> 

在過去，這使用

fut = new Future(); 
// set off chain passing future 
future.wait(); 

誠徵我會做去挑選那裏最好最聰明的大腦。

在此先感謝您的時間！ Elliott

Answer 1

您將需要返回一個承諾，當發電機完成時將解決。我真的建議使用現有的實現像co但是如果你想擴大自己的實現：

var runPromiseGenerator = function(generator) { 
    return new Promise(function(resolve, reject){ 
    var it = generator(), ret; 

    // asynchronously iterate over generator 
    (function iterate(val) { 
     try { 
     ret = it.next(val); 

     if (!ret.done) { 
      Promise.resolve(ret.value).then(iterate, reject); 
     } 
     else { 
      resolve(ret.value); 
     } 
     } 
     catch (e){ 
     reject(e); 
     } 
    })(); 
    }); 
}; 

那麼你就可以改變你的execute是

execute() { 
    let _this = this; 

    return runPromiseGenerator(function *promiseGenerator() { 
    yield _this.asyncMethod1(); 
    yield _this.asyncMethod2(); 
    yield _this.asyncMethod3(); 
    }); 
} 

，做

p.execute().then(function(){ 
    // done 
}); 

或者，您可以使用您現有的功能來調用它，例如

runPromiseGenerator(function *promiseGenerator() { 
    yield p.execute(); 

    // do something after execution 
});