es6,promise,generator,next,yield与koa

es6里有了很多新特性

promise是一种形式，使用promise可以让异步的代码像同步代码，从而更符合人类的思维方式，使回调函数的写法变得轻松

在函数中使用promise,一般是return一个用promise包裹的函数，如：

function t(arg){
    //准备工作，处理等
    // 。。。
    var istrue =arg+1
    //处理结束
    return new promise(function(resolve,reject{
        //判定并返回
        if(istrue!='3'){
          console.log(istrue)
          resolve();
        }else{
          reject();
        }
    }))
}
t(3)
.then(t(1))
.then(t(8))
.then(t(2))

关于promise函数的感性认识可以猛击：http://www.zhangxinxu.com/wordpress/2014/02/es6-javascript-promise-%E6%84%9F%E6%80%A7%E8%AE%A4%E7%9F%A5/

generator就是一个状态机函数，在generator函数内部用yield关键字进行分块，在调用generator函数时，用.next()方法进入下一个状态：

function* quips(name) {
  yield "hello " + name + "!";
  yield "i hope you are enjoying the blog posts";
  if (name.startsWith("X")) {
    yield "it's cool how your name starts with X, " + name;
  }
  yield "see you later!";
}
> var iter = quips("jorendorff");
  [object Generator]
> iter.next()
  { value: "hello jorendorff!", done: false }
> iter.next()
  { value: "i hope you are enjoying the blog posts", done: false }
> iter.next()
  { value: "see you later!", done: false }
> iter.next()
  { value: undefined, done: true }

每次调用.next()函数的返回值是一个包含value和done两个元素的对象。

引用http://web.jobbole.com/82903/的话：

每当 Generator 函数执行遇到 yield 表达式时，函数的栈帧 — 本地变量，函数参数，临时值和当前执行的位置，就从堆栈移除，但是 Generator 对象保留了对该栈帧的引用，所以下次调用 .next() 方法时，就可以恢复并继续执行。

然而generator并不是多线程，

在支持多线程的语言中，同一时间可以执行多段代码，并伴随着执行资源的竞争，执行结果的不确定性和较好的性能。而 Generator 函数并不是这样，当一个 Generator 函数执行时，它与其调用者都在同一线程中执行，每次执行顺序都是确定的，有序的，并且执行顺序不会发生改变。与线程不同，Generator 函数可以在内部的 yield 的标志点暂停执行。

 

 使用generator来做回调：

function delay(time, callback){
    setTimeout(function(){
        callback("Slept for "+time);
    },time);
}

function run(generatorFunction) {
    var generatorItr = generatorFunction(resume);

    function resume(callbackValue) {
        generatorItr.next(callbackValue);
    }

    generatorItr.next()
}
run(function* myDelayedMessages(resume) {
    console.log(yield delay(1000, resume));
    console.log(yield delay(1200, resume));
});

解释一下：generator函数返回一个迭代器，这里就是generatorItr,它在resume里被调用使用next(callbackValue)方法，将resume的参数callbackValue传入给yield的前的对象。

这里实际上就是把yield后语句的返回值传给yield前的对象，并且持续转进到下一个状态。

koa就实现了这个run方法的机制，不用我们写了

'use strict'
var koa = require('koa')
var app = koa();
var fs =require('fs')

app.use(function *(next){
 var content = yield readFileAsync('./index.html');
 console.log('this is '+content);
 console.log('body. '+content);
 this.body=content;
});

function readFileAsync(fpath){
  return new Promise(function(resolve,reject){   
    fs.readFile(fpath,'utf-8',function(err,content){
      if(err) reject(err)
      else {
        resolve(content)}
    })
  })
}
var port = 3001;
app.listen(port)
console.log('listening on port '+ port)

 网上有一些自己实现了简单的koa框架的，我们可以参考这些代码，来总结koa框架的使用规律。比如一个实现了koa 中的co函数及使用例子如下

function co(generator){
    var gen = generator();

    var next = function(data){
        var result = gen.next(data);

        if(result.done) return;

        if (result.value instanceof Promise) {
          console.log("in if (result.value instanceof Promise)");
            result.value.then(function (d) {
                next(d);
            }, function (err) {
                next(err);
            })
        }else {
            next();
        }
    };

    next();
}
co(function*(){
    var text1 = yield new Promise(function(resolve){
        console.log("in 1st Promise");
        setTimeout(function(){
            resolve("I am text1");
        }, 1000);
    });

    console.log(text1);

    var text2 = yield new Promise(function(resolve){
        setTimeout(function(){
            resolve("I am text2");
        }, 1000);
    });

    console.log(text2);
});

koa use 方法中的参数必须是一个generator函数或者可以返回一个generator函数对象，这个函数假设为g，g里用yield关键字进行异步调用，而yield后必须返回一个promise对象，因为在co函数里，需要调用yield 返回的对象的then方法进行参数传递或者错误信息传递。

co函数负责取到yield返回promise对象的运行结果，并传递给yield关键字之前的值，随后调用generator函数的next方法推动generator函数继续往下走。