什么是遍历器对象？

遍历器对象也称为指针对象。
就是一个对象格式为{ next: function() { }} 的a对象， 在这个next里面处理集合。
然后a.next() 就可以访问这个集合里面的一个值。返回的是{value:'',done:false} 这样的对象
注意：遍历器对象除了有next方法，还可以有return和throw方法。

什么是遍历器函数？

一个函数 返回的是遍历器对象，就称为遍历器函数。
其中Generator函数返回的就是遍历器对象。它就是一个遍历器函数。

什么是 Iterator 接口

Iterator 接口的目的，就是为所有数据结构，提供了一种统一的访问机制，即for...of循环（详见下文）。当使用for...of循环遍历某种数据结构时，该循环会自动去寻找 Iterator 接口。

一种数据结构只要部署了 Iterator 接口，我们就称这种数据结构是“可遍历的”（iterable）。

ES6 规定，默认的 Iterator 接口部署在数据结构的Symbol.iterator属性，或者说，一个数据结构只要具有Symbol.iterator属性，就可以认为是“可遍历的”（iterable）。Symbol.iterator属性本身是一个函数，就是当前数据结构默认的遍历器生成函数。执行这个函数，就会返回一个遍历器。至于属性名Symbol.iterator，它是一个表达式，返回Symbol对象的iterator属性，这是一个预定义好的、类型为 Symbol 的特殊值，所以要放在方括号内

Generator函数

Generator函数执行返回的是遍历器对象，一方面此函数可用做遍历器对象的生成，那作用体现在用于遍历内容。另一方面应用是用于异步。体现在调用next的时候，去执行yield后面的内容。从而达到异步情况下，可以读取异步完成后的内容。真实的目的同样是解决异步回调地狱的问题。
generator函数处理异步的时候，如何做到自执行呢？则依赖于Thunk函数 或者 CO模块（原理使用promise或者thunk函数）。
thunk函数如下

// ES6版本
const Thunk = function(fn) {
  return function (...args) {
    return function (callback) {
      return fn.call(this, ...args, callback);
    }
  };
};
var readFileThunk = Thunk(fs.readFile);
readFileThunk(fileA)(callback) //callback里面可以获取异步的内容

// 借助于thunk实现自动执行
var gen = function* (){
  var r1 = yield readFileThunk('/etc/fstab');
  console.log(r1.toString());
  var r2 = yield readFileThunk('/etc/shells');
  console.log(r2.toString());
}; 
var g = gen(); 
var r1 = g.next();
r1.value(function (err, data) {
  if (err) throw err;
  var r2 = g.next(data);
  r2.value(function (err, data) {
    if (err) throw err;
    g.next(data);
  });
});

//完整代码
function run(fn) {
  var gen = fn();

  function next(err, data) {
    var result = gen.next(data);
    if (result.done) return;
    result.value(next);
  }
  next();
}
function* g() {
  // ...
}
run(g);

CO 模块

var co = require('co');
co(gen); 
co(gen).then(function (){
  console.log('Generator 函数执行完成');
});
 
var fs = require('fs');
// 利用promise。返回的为promise
var readFile = function (fileName){
  return new Promise(function (resolve, reject){
    fs.readFile(fileName, function(error, data){
      if (error) return reject(error);
      resolve(data);
    });
  });
};

var gen = function* (){
  var f1 = yield readFile('/etc/fstab');
  var f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

//完整
function run(gen){
  var g = gen();

  function next(data){
    var result = g.next(data);
    if (result.done) return result.value;
    result.value.then(function(data){
      next(data);
    });
  }

  next();
}

run(gen);

async函数

generator函数的语法糖。其实就是结合了generator函数和他的自执行器co实现的。

const fs = require('fs');

const readFile = function (fileName) {
  return new Promise(function (resolve, reject) {
    fs.readFile(fileName, function(error, data) {
      if (error) return reject(error);
      resolve(data);
    });
  });
};

const gen = function* () {
  const f1 = yield readFile('/etc/fstab');
  const f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};
// 上面代码的函数gen可以写成async函数
const asyncReadFile = async function () {
  const f1 = await readFile('/etc/fstab');
  const f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

async函数对 Generator 函数的改进，体现在以下四点
（1）内置执行器。

Generator 函数的执行必须靠执行器，所以才有了co模块，而async函数自带执行器。也就是说，async函数的执行，与普通函数一模一样，只要一行。

asyncReadFile();

上面的代码调用了asyncReadFile函数，然后它就会自动执行，输出最后结果。这完全不像 Generator 函数，需要调用next方法，或者用co模块，才能真正执行，得到最后结果。

（2）更好的语义。

async和await，比起星号和yield，语义更清楚了。async表示函数里有异步操作，await表示紧跟在后面的表达式需要等待结果。

（3）更广的适用性。

co模块约定，yield命令后面只能是 Thunk 函数或 Promise 对象，而async函数的await命令后面，可以是 Promise 对象和原始类型的值（数值、字符串和布尔值，但这时会自动转成立即 resolved 的 Promise 对象）。

（4）返回值是 Promise。

async函数的返回值是 Promise 对象，这比 Generator 函数的返回值是 Iterator 对象方便多了。你可以用then方法指定下一步的操作。

进一步说，async函数完全可以看作多个异步操作，包装成的一个 Promise 对象，而await命令就是内部then命令的语法糖。

异步遍历器

为了解决generator返回的遍历器是同步的，所以执行异步的话，要依赖其他的模块。所以直接可以返回一个异步遍历器。

和async函数的区别
async 多用于 一个命令一个命令执行。也就是命令式编程
而异步遍历器偏向于可以做到的是，多个请求一起发，然后可以顺序输出。更方便一点。（可能理解的不够）

大致关系图。（我是这样理解的，若有不对，望指出。）

image.png