module.exports = {
    extends: ["@commitlint/config-conventional"],
};

"husky": {
    "hooks": {
        "pre-commit": "lint-staged"
    }
},
"lint-staged": {
    "**/*.js": [
        "prettier --write", 
        "eslint"
    ]
}

// 安装 eslint 和 prettier 相关依赖：
npm install eslint eslint-config-prettier eslint-plugin-promise eslint-plugin-react eslint-plugin-react-hooks prettier babel-eslint -D

module.exports = {
  printWidth: 100, //长度超过100断行
  singleQuote: true,//使用单引号
};

dist
node_modules
public

module.exports = {
  settings: {
    react: {
      pragma: 'React',
      version: 'detect'
    }
  },
  // babel parser to support ES6/7 features
  parser: 'babel-eslint',
  parserOptions: {
    ecmaVersion: 7,
    ecmaFeatures: {
      experimentalObjectRestSpread: true,
      jsx: true
    },
    sourceType: 'module'
  },
  extends: [
    'prettier', 
    'prettier/react'
  ],
  plugins: [
    'promise', 
    'react', 
    'react-hooks'
  ],
  env: {
    browser: true,
    es6: true,
    node: true
  },
  rules: {
    'no-compare-neg-zero': 2, //禁止与 -0 进行比较
    'no-cond-assign': 2, //禁止条件表达式中出现赋值操作符
    'no-console': 1, //禁用 console
    'no-constant-condition': 1, //禁止在条件中使用常量表达式
    'no-control-regex': 1, //禁止在正则表达式中使用控制字符
    'no-debugger': 2, //禁用 debugger
    'no-dupe-args': 2, //禁止 function 定义中出现重名参数
    'no-dupe-keys': 2, //禁止对象字面量中出现重复的 key
    'no-duplicate-case': 2, //禁止出现重复的 case 标签
    'no-const-assign': 1, //禁止修改const声明的变量
    'no-empty': 1, //禁止出现空语句块
    'no-empty-character-class': 2, //禁止在正则表达式中使用空字符集
    'no-ex-assign': 2, //禁止对 catch 子句的异常参数重新赋值
    'no-extra-boolean-cast': 1, //禁止不必要的布尔转换
    'no-extra-semi': 1, //禁止不必要的分号
    'no-func-assign': 2, //禁止对 function 声明重新赋值
    'no-inner-declarations': 0, //禁止在嵌套的块中出现变量声明或 function 声明,ES6中无需禁止
    'no-invalid-regexp': 2, //禁止 RegExp 构造函数中存在无效的正则表达式字符串
    'no-irregular-whitespace': 1, //禁止在字符串和注释之外不规则的空白
    'no-obj-calls': 2, //禁止把全局对象作为函数调用，比如Math() JSON()
    'no-regex-spaces': 1, //禁止正则表达式字面量中出现多个空格
    'no-sparse-arrays': 1, //禁用稀疏数组
    'no-unexpected-multiline': 1, //禁止出现令人困惑的多行表达式
    'no-unreachable': 1, //禁止在return、throw、continue 和 break 语句之后出现不可达代码
    'no-unsafe-finally': 2, //禁止在 finally 语句块中出现控制流语句
    'no-unsafe-negation': 1, //禁止对关系运算符的左操作数使用否定操作符
    'use-isnan': 2, //要求使用 isNaN() 检查 NaN，如 isNaN(foo),而非foo == NaN
    'valid-typeof': 2, //强制 typeof 表达式与有效的字符串(如: 'undefined', 'object', 'boolean', 'number', 'string', 'function','symbol')进行比较
    'no-case-declarations': 1, //不允许在 case 子句中使用词法声明
    'no-empty-pattern': 2, //禁止使用空解构模式
    'no-fallthrough': 2, //禁止 case 语句落空
    'no-global-assign': 2, //禁止对原生对象或只读的全局对象进行赋值
    'no-octal': 1, //禁用八进制字面量
    'no-redeclare': 1, //禁止多次声明同一变量
    'no-self-assign': 1, //禁止自我赋值
    'no-unused-labels': 1, //禁用出现未使用过的标
    'no-useless-escape': 1, //禁用不必要的转义字符
    'no-delete-var': 2, //禁止删除变量
    'no-undef': 2, //禁用使用未声明的变量，除非它们在 /*global */ 注释中被提到
    'no-unused-vars': 1, //禁止出现未使用过的变量
    'constructor-super': 2, //要求在构造函数中有 super() 的调用
    'no-class-assign': 2, //禁止给类赋值
    'no-dupe-class-members': 2, //禁止类成员中出现重复的名称
    'no-new-symbol': 2, //禁止 Symbol 和 new 操作符一起使用
    'no-this-before-super': 2, //禁止在构造函数中，在调用 super() 之前使用 this 或 super
    'require-yield': 2, //要求 generator 函数内有 yield
    'no-mixed-spaces-and-tabs': 1, //要求不适用space，tab混用
    'react/forbid-prop-types': [1, { forbid: ['any'] }], //禁止某些propTypes
    'react/prop-types': 1, //没用对props类型进行校验
    'react/jsx-closing-bracket-location': 1, //在JSX中验证右括号位置
    'react/jsx-curly-spacing': [1, { when: 'never', children: true }], //在JSX属性和表达式中加强或禁止大括号内的空格。
    'react/jsx-key': 2, //在数组或迭代器中验证JSX具有key属性
    'react/jsx-max-props-per-line': [1, { maximum: 1 }], // 限制JSX中单行上的props的最大数量
    'react/jsx-no-duplicate-props': 2, //防止在JSX中重复的props
    'react/jsx-no-undef': 1, //在JSX中禁止未声明的变量
    'react/no-string-refs': 1, //Using string literals in ref attributes is deprecated
    'react/jsx-uses-react': 1, //防止反应被错误地标记为未使用
    'react/jsx-uses-vars': 1, //防止在JSX中使用的变量被错误地标记为未使用
    'react/no-danger': 1, //防止使用危险的JSX属性
    'react/no-did-update-set-state': 2, //防止在componentDidUpdate中使用setState
    'react/no-did-mount-set-state': 0, //防止在componentDidUpdate中使用setState
    'react/no-direct-mutation-state': 2, //防止this.state赋值
    'react/no-unknown-property': 2, //防止使用未知的DOM属性
    'react/prefer-es6-class': 1, //为React组件强制执行ES5或ES6类
    'react/react-in-jsx-scope': 0, //使用JSX时，必须要引入React
    'react/sort-comp': 0, //强制组件方法顺序
    'react/sort-prop-types': 0, //强制组件属性顺序
    'react/jsx-sort-props': 1,
    'react/no-deprecated': 1, //不使用弃用的方法
    'react/jsx-equals-spacing': 1, //在JSX属性中强制或禁止等号周围的空格
    'react/wrap-multilines': 0,
    'comma-dangle': 1, //对象字面量项尾不能有逗号
    'react/no-multi-comp': 0, //防止每个文件有多个组件定义
    'flowtype/generic-spacing': 0, //泛型对象的尖括号中类型前后的空格规范
    'flowtype/space-after-type-colon': 0, //类型注解分号后的空格规范
    // react-hooks
    'react-hooks/rules-of-hooks': 'error',
    'react-hooks/exhaustive-deps': 'warn'
  }
};

/**
 * Book类，代表一个书本.
 * @constructor
 * @param {string} title - 书本的标题.
 * @param {string} author - 书本的作者.
 */
function Book(title, author) {
  this.title = title;
  this.author = author;
}
Book.prototype = {
  /**
   * 获取书本的标题
   * @returns {string|*}
   */
  getTitle: function () {
    return this.title;
  },
  /**
   * 设置书本的页数
   * @param pageNum {number} 页数
   */
  setPageNum: function (pageNum) {
    this.pageNum = pageNum;
  },
};

let p1 = new Promise((resolve,reject) => {
  resolve(1)
})

p1.then()
  .then(value => {
    console.log(value);
    return value + 1
  }).then(value => {
    console.log(value);
  })

// output: 1 2

//  两者不等价
let p2 = Promise.resolve(1);
p2.then(v => { v + 1 })
  .then(v => { console.log(v)});

// output: 2

let p3 = Promise.resolve(1);
p3.then(v => v + 1);
p3.then(v => console.log(v));

// output: 1

let p4 = Promise.resolve(1);
p4.then(v => {
  return new Promise((resolve,reject) => {
    setTimeout(() => resolve(2))
  })
}).then(v => console.log(v));

// output: 2

let p1 = new Promise((resolve , reject) => {
  reject(new Error ('some wrong'))
})

let p2 = p1.then(
  value => { console.log(value) },
  reason => { console.log(reason.message) }
)

// output: something wrong

p2.then(()=>{
  throw new Error('something wrong 1')
}).catch(reason => {
  console.log(reason.message)
})

// output: something wrong 1

Promise.reject(new Error('error')))
  .catch(reason => {
    console.log(reason.message);
    return `${reason.message} occured`
  }).then(v => console.log(v));

// output: error error occured 

function sleep(duration){
  return new Promise((resolve,reject) =>{
    setTimeout(() => {resolve(),duration})
  })
}

async function run(){
  const start = Date.now();
  await sleep(1000);
  await sleep(2000);
  await sleep(3000);
  console.log(Date.now() - start)
}

run()
// ==== 以下是 promise 的书写方法 === //
function run1(){
  const start = Date.now();
  return Promise.resolve()
    .then(function() { return sleep(1000)})
    .then(function() { return sleep(2000)})
    .then(function() { return sleep(3000)})
    .then(function() { console.log(Date.now() - start)})
}

run1();

//  Promise 状态有 3 个  
const PENDING = 0;
const FULFILLED = 1;
const REJECTED = 2;
class Promise {
  constructor(fn){
     //  初始状态
    this._state = PENDING;
    this._data = null;

    this._onFulfilledCallbacks = [];
    this._onRejectedCallbakcs = [];

    run(this,fn);
  }

  static deferred (){
    const dfd = {}
    dfd.promise = new promise ((resonlve,reject) => {
      dfd.resolve = resolve;
      dfd.reject = reject;
    })
    return dfd;
  }

  then(onFulfilled, onRejected){
    if(typeof onFulfilled !== 'function'){
      onFulfilled = function(data){
        return data
      }
    }
    if(typeof onRejected !== 'function'){
      onRejected = function(reason){
        throw reason
      }
    }

    let promise2;

    if(this._state === FULFILLED){
      promise2 = new Promise((resolve,reject ) =>{
        setTimeout(()=>{
          try{
            const x = onFulfilled(this._data)
            resolvePromise(promise2,x,resolve,reject)
          }catch(e){
            reject(e);
          }
        })
      })
    }else if(this._state === REJECTED){
      promise2 = new Promise((resolve,reject ) =>{
        setTimeout(()=>{
          try{
            const x = onRejected(this._data)
            resolvePromise(promise2,x,resolve,reject)
          }catch(e){
            reject(e);
          }
        })
      })

    }else if(this._state === PENDING){
      promise2 = new Promise((resolve,reject)=>{
        this._onFulfilledCallbacks.push(data => {
          try{
            const x = onFulfilled(data)
            resolvePromise(promise2,x,resolve,reject)
          }catch(e){
            reject(e)
          }
        })
        this._onRejectedCallbakcs.push(reason =>{
          try{
            const x = onRejected (reason)
            resolvePromise(promise2,x,resolve,reject)
          }catch(e){
            reject(e)
          }
        })
      })
    }
  }
  return promise2
}

catch(onRejected){
  return this.then(undefined,onRejected)
}

function resolvePromise (promise2,x,resolve,reject){
  if(x instanceof Promise){
    return x.then(resolve,reject);
  }else{
    resolve(x)
  }
}
function run (promise,fn){
  try{
    fn(
      data => {
        // do resolve
        resolve(promise,data)
      },
      reason => {
        // do reject
        reject(promise,reason)
      }
    )
  }catch(e){
    // reject
    reject(promise,e)
  }
}

function resolve(promise,data) {
  // 处理值是 Promise 的情况
  if(data instanceof Promise){
    return data.then(
      d => { resolve (promise,d)},
      r => { reject (promise,r)}
    )
  }
  if(promise._state !== PENDING){
    callback(data)
  }

  setTimeout(()=>{
    promise._state = FULFILLED;
    promise._data = data;

    for(let callback of promise._onFulfilledCallbacks) {
      callback(data)
    }
  })

}

function reject(promise,reason) {
  if(promise._state !== PENDING){
    return
  }

  setTimeout(()=>{
    promise_state = REJECTED
    promise_data = reason

    for (let callback of promise__onRejectedCallbakcs){
      callback(reason   )
    }
  })
}

module.exports = Promise;

  document.getElementById("start").addEventListener("click", start, false);

  function start() {
    // 响应事件，进行相应的操作
  }

// jQuery 用 '.on()' 也是事件监听
  $("#start").on("click", start);

$.ajax("http://baidu.com", {
  success: function (res) {
    // 这里就是回到函数了
  },
});

// 或者在页面加载完毕后回调
$(function () {
  //  这里也是回调函数
});

new Promise(
  /* 执行器 executor */
  function (resolve, reject) {
    // 一段耗时很长的异步操作

    resolve(); // 数据处理完成

    reject(); // 数据处理出  错 
  }
).then(
  function A() {
    // 成功，下一步
  },
  function B() {
    // 失败，做相应处理
  }
);

new Promise((resolve) => {
  setTimeout(() => {
    resolve("hello");
  }, 2000);
}).then((value) => {
  console.log(value + "world");
});

// 两步执行范例
new Promise( resolve =>{
  setTimeout(()=>{
    resolve('hello');
  },2000);
}).then( value => {
  console.log(value);
  return new Promise( resolve =>{
    setTimeout(() => {
      resolve('world');
    },2000);
  });
}).then( value =>{
  console.log( value + 'world');
})

// 对已完成的 promise 执行
let promise = new Promise(resolve =>{
  setTimeout(() => {
    console.log('the promise fulfilled');
    resolve('hello,world');
  },1000)
})

setTimeout(()=>{
  promise.then( value =>{
    console.log(value);
  })
},3000)

// then 里不返回 promise
new Promise( resolve =>{
  setTimeout(() =>{
    resolve('hello');
  },2000);
}).then(value =>{
  console.log(value);
  console.log('everyone');
  (function (){
    return new Promise(resolve => {
      setTimeout(()=>{
        console.log('Mr.Laurence');
        resolve(' Merry Xmas ');
      },2000)
    });
  }());
  return false;
}).then( value =>{
  console.log(value + ' world');
})

console.log('start')
new Promise( resolve =>{
  console.log('Step 1');
    setTimeout(() =>{
      resolve('1000');
    },1000);
  }).then(value =>{
    return new Promise( resolve =>{
      console.log('Step 1-1');
      setTimeout(()=>{
        resolve(110);
      },1000)
    }).then( value => {
      console.log('Step 1-2');
      return value;
    }).then(value => {
      console.log('Step 1-3');
      return value;
    })
  }).then( value =>{
    console.log(value);
    console.log('Step 2');
  })

// 展开
console.log('start')
new Promise( resolve =>{
  console.log('Step 1');
    setTimeout(() =>{
      resolve('1000');
    },1000);
  }).then(value =>{
    return new Promise( resolve =>{
      console.log('Step 1-1');
      setTimeout(()=>{
        resolve(110);
      },1000)
    })
  }).then( value => {
      console.log('Step 1-2');
      return value;
    }).then(value => {
      console.log('Step 1-3');
      return value;
    }).then( value =>{
    console.log(value);
    console.log('Step 2');
  })

doSomething().then(function(){
  return doSomethingElse()
});


// doSomething().then(function(){
//   return doSomethingElse();
// }).then(finalHandler);

// 答案
// doSomething
// |-----------|
//             doSomethingElse(undefined)
//             |------------|
//                          finalHandler(resultOfDoSomethingElse)
//                          |------------|


doSomething().then(function(){
  doSomethingElse()
});

// doSomething().then(function(){
//   doSomethingElse();
// }).then(finalHandler);

// 答案
// doSomething
// |-----------|
//             doSomethingElse(undefined)
//             |------------|
//             finalHandler(resultOfDoSomethingElse)
//             |------------|

doSomething().then(
  doSomethingElse()
);

// doSomething().then(
//   doSomethingElse();
// ).then(finalHandler);

// 答案
// doSomething
// |-----------|
// doSomethingElse(undefined)
// |----------------------------|
//             finalHandler(resultOfDoSomethingElse)
//             |------------|


doSomething().then(
  return doSomethingElse
);

// doSomething().then(
//   doSomethingElse;
// ).then(finalHandler);

// 答案
// doSomething
// |-----------|
//             doSomethingElse(resultOfDosomething)
//             |------------|
//                          finalHandler(resultOfDoSomethingElse)
//                          |------------|

new Promise( resolve =>{
  setTimeout(()=>{
    throw new Error('bye');
  },2000);
}).then( value =>{
  console.log(value + 'world');
}).catch( error =>{
  console.log( 'Error:',error.message )
})

new Promise( (resolve,reject) =>{
  setTimeout(()=>{
    reject('bye');
  },2000);
}).then( value =>{
  console.log(value + 'world');
},value =>{
  console.log('Error',value);
})

new Promise(resolve =>{
  setTimeout(()=>{
    resolve();
  },1000)
}).then(()=>{
  console.log('start');
  throw new Error('test error');
}).catch( err => {
  console.log('I catch ',err);
  // throw new Error('another error');
}).then(()=>{
  console.log('arrive here');
}).then(()=>{
  console.log('...and here');
}).catch( err =>{
  console.log('No,I catch',err);
})

doSomething()
  .doAnotherThing()
  .doMoreThing()
  .catch( err =>{
    console.log(err);
  })

Promise.all([1,2,3]).then( all => {
  console.log('1: ',all);
  return Promise.all([function(){
    console.log('ooxx');
  },'xxoo',false]);
}).then(all =>{
  console.log('2: ',all);
  let p1 = new Promise( resolve =>{
    setTimeout(()=>{
      resolve('I\'m P1');
    },1500)
  })
  let p2 = new Promise( resolve =>{
    setTimeout(()=>{
      resolve('I\'m P2');
    },1450)
  })
  return Promise.all([p1,p2]);
}).then( all =>{
  console.log('3: ',all);
  let p1 = new Promise( resolve =>{
    setTimeout(() => {
      resolve('I\'m P1');
    },1500)
  })
  let p2 = new Promise( (resolve,reject)  =>{
    setTimeout(() => {
      reject('I\'m P2');
    },1000)
  })
  let p3 = new Promise( (resolve,reject) =>{
    setTimeout(() => {
      reject('I\'m P3');
    },3000)
  })
}).then( all =>{
  console.log('all',all);
}).catch(err =>{
  console.log(err);
})

const fs = require('fs');
const path = require('path');
const FileSystem = require('./FileSystem');

function findLargest(dir) {
      return FileSystem.readDir(dir, 'utf-8').then( files => {
    return Promise.all( files.map( file => {
      return new Promise (resolve => {
        fs.stat(path.join(dir, file), (err, stat) => {
          if (err) throw err;
            if (stat.isDirectory()) {
              return resolve({
                size: 0
              });
            }
            stat.file = file;
              resolve(stat);
            });
          });
        }));
      }).then( stats => {
        let biggest = stats.reduce( (memo, stat) => {
        if(memo.size < stat.size) {
          return stat;
        }
          return memo;
        });
          return biggest.file;
        })
      }

function queue(things){
  let promise = Promise.resolve();
  things.forEach( thing =>{
    promise = promise.then(()=>{
      return new Promise( resolve =>{
        doThing(thing,()=>{
          resolve();
        });
      })
    })
  })
  return promise;
}
queue('lots','of','things',...)

function queue(things){
  return things.reduce((promise,thing) => {
    return promise.then(() => {
      return new Promise( resolve => {
        doThing(thing,()=>{
          resolve();
        });
      });
    });
  },Promise.resolve());
}
queue('lots','of','things',...)

let url = ['http://blog.meathill.com/'];
function fetchAll(urls) {
    return urls.reduce((promise, url) => {
        return promise.then( () => {
          return fetch(url);
        });
    }, Promise.resolve());
}
function fetch(url) {
    return spider.fetch(url)
        .then( content => {
          return saveOrOther(content);
        })
        .then( content => {
          let links = spider.findLinks(content);
          return fetchAll(links);
        });
}
fetchAll(url);

Promise.resolve().then( (value) => {
  console.log('Step 1', value);
  return Promise.resolve('Hello');
}).then( value =>{
  console.log(value,'World');
  return Promise.resolve(new Promise( resolve => {
    setTimeout(()=>{
      resolve('Good');
    },2000);
  }));
}).then( value => {
  console.log(value, 'evening');
  return Promise.resolve({
    then(){
      console.log(', everyone');
    }
  })
})

let promise = Promise.reject('something wrong');

promise.then( () => {
    console.log('it\'s ok');
  }).catch( () => {
      console.log('no, it\'s not ok');
      return Promise.reject({
      then() {
        console.log('it will be ok');
      },
      catch() {
        console.log('not yet');
      }
    });
  });

let p1 = new Promise(resolve => {
  // 这是一个长时间的调用
  setTimeout(() => {
      resolve('I\'m P1');
  }, 10000);
});

let p2 = new Promise(resolve => {
  // 这是个稍短的调用
  setTimeout(() => {
      resolve('I\'m P2');
  }, 2000)
});

Promise.race([p1, p2]).then(value => {
  console.log(value);
});

const fs = require('fs');

module.exports = {
  // 读取目录  
  readDir: function (path, options) {
    return new Promise( resolve => {
      fs.readdir(path, options, (err, files) => {
        if (err) {
          throw err;
        }
        resolve(files);
      });
    });
  },
  // 读取文件
  readFile: function (path, options) {
    return new Promise( resolve => {
      fs.readFile(path, options, (err, content) => {
        if (err) {
          throw err;
        }
        resolve(content);
      });
    });
  }
};

// 使用
const fs = require('./FileSystem');

fs.readFile('../README.md','utf-8').then(content =>{
  console.log(content);
})

// 弹出窗体
let confirm = popupManager.confirm('您确定么？');
confirm.promise.then(() => {
  // do confirm staff
})
.catch(() => {
  // do cancel staff
});

// 窗体的构造函数
class Confirm {
  constructor() {
    this.promise = new Promise( (resolve, reject) => {
      this.confirmButton.onClick = resolve;
      this.cancelButton.onClick = reject;
    })
  }
}

// 对已完成的 promise 执行
let promise = new Promise(resolve =>{
  setTimeout(() => {
    console.log('the promise fulfilled');
    resolve('hello,world');
  },1000)
})

setTimeout(()=>{
  promise.then( value =>{
    console.log(value);
  })
},3000)

getlist(data){
  this.api.getlist(data).then(res=>{
    this.list = res.data.data;
  })
}

// 下拉刷新
pullDown(){
  this.getlist(data);
}

getlist(data){
  return this.api.getlist(data).then(res=>{
    return Promise.resolve(res.data.data);
  })
}

// 模糊搜索
querySearchAsync(){
  this.getlist(data).then((value)=>{
    this.searchlist = value;
  })
}

$.ajax(url,{
  dataType: 'json'
}).then(json =>{
  // 进行操作
})

fetch('some.json').then( res =>{
  return res.json()
}).then( json =>{
  // do something with the json
}).catch( err =>{
  console.log(err);
})

async function f1(){
  const result = await resolveAfter2Seconds();
  console.log(result);
}

function f(m){
  return m * 2;
}

f(x + 5);
// 等同于
var thunk = function () {
  return x + 5;
};

function f(thunk){
  return thunk() * 2;
}

// 正常版本的readFile（多参数版本）
fs.readFile(fileName, callback);

// Thunk版本的readFile（单参数版本）
var readFileThunk = Thunk(fileName);
readFileThunk(callback);

var Thunk = function (fileName){
  return function (callback){
    return fs.readFile(fileName, callback); 
  };
};

var Thunk = function(fn){
  return function (){
  var args = Array.prototype.slice.call(arguments);
    return function (callback){
      args.push(callback);
      return fn.apply(this, args);
    }
  };
};

// 使用上面的转换器，生成 fs.readFile 的 Thunk 函数。
var readFileThunk = Thunk(fs.readFile);
readFileThunk(fileA)(callback);

var fs = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile);

var gen = function* (){
  var r1 = yield readFile('/etc/fstab');
  console.log(r1.toString());
  var r2 = yield readFile('/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();
}
run(gen);

function* gen(x){  // * 号区别
try {
  var y = yield x + 2; // yield 暂停
} catch (e){
  console.log(e);
}
  return y;
}

var g = gen(1); // 返回的是指针对象
g.next() // { value: 3, done: false } value 属性是 yield 语句后面表达式的值
g.next() // { value: undefined, done: true } Generator 是否执行完毕
// 有参数2，这个参数可以传入 Generator 函数，作为上个阶段异步任务的返回结果，被函数体内的变量 y 接收。
g.next(2) // { value: 2, done: true }
g.throw（'出错了'） // 捕获错误并抛出