ES6 generator 与 koa 中间件 是如何 generator解决异步的

标签（空格分隔）： JS 同步编程异步执行 异步 同步

---

参考文章：
koa如何利用generator解决回调：http://blog.stevensanderson.com/2013/12/21/experiments-with-koa-and-javascript-generators/

常规的 generator 概览

// 自己编写的 demo
function print(data){
    console.log('传入的参数是：',data)
}
function *g(fn){
    for(var i=0;i<10;i++){
        yield i 
        yield fn(i)
    }
}
var gg = g(print)  // 此处有 generator，暂停变成同步执行
gg.next()   // 此处是同步阻塞的  {value:'0',done:false}
// 当 gg.next() 返回 {value:undefined,done:true} 时， generator 函数才执行完并退出，之后再次变成异步模式
console.log('此处会第一步执行吗？')

上述例子并不太像一般的函数封装，看下面这个例子

function *request(url,fn){
    yield fn(url) // 简略不写数据请求了；
}
function *g(){
    var result = []
    for(var i=0;i<5;i++){
        var r_result = yield request(url)
        result.push(r_result) // 保证了传入的顺序是对的
    }
    return result // 最后返回了一个结果
}

koa 是如何 generator 的呢？

var koa = require('koa'),
    app = koa();

app.use(function *() {
    // Here is the important bit of application logic for this example.
    // We make use of a series of async operations without callbacks.

    var city = yield geolocation.getCityAsync(this.req.ip);
    var forecast = yield weather.getForecastAsync(city); // 此处的参数需要同步传进来

    this.body = 'Today, ' + city + ' will be ' + forecast.temperature + ' degrees.';
});

app.listen(8080); 

//根据上面代码，个人目前猜想实现 use 过程是：
function koa(){
    var use = function *(fn){
        whild(fn().next().done != true){
            fn().next()
        }
    }
    return {
        use,
    }
}
//猜想： koa 内部会一直调用 generator，直到 done为 true 时才会退出

低版本 koa 不支持 promise 时，可以 thunk 形式来让 koa 识别
thunk == promise 相同的功能

// Wrap the async operation in a 'thunk' so that Koa understands it
function getSquareValueThunk(num) {
    // A 'thunk' returns a function that accepts a callback
    return function(callback) {
        getSquareValueAsync(num, callback);
    };
}

app.use(function *() {
    var square = yield getSquareValueThunk(16);
    this.body = "Square of 16 is " + square;
});