1.async和await

什么是async？什么是await?

	async用于修饰函数，放置在函数的开始位置，被修饰的函数一定返回一个promise对象,简单来说就是用来简化promise创建的。await相当于then，await关键字必须写在async函数中。

async语法

	async function name([param[, param[, ... param]]]) { statements }参数：name 函数名称。param 要传递给函数的参数。statements 函数体语句。
返回值返回的Promise对象会运行执行(resolve)异步函数的返回结果，或者运行拒绝(reject)——如果异步函数抛出异常的话。

  一个async异步函数可以包含0个或者多个await指令，该指令会暂停异步函数的执行，并等待Promise执行，然后继续执行异步函数，并返回结果。

  记住await关键字只在异步函数内有效。如果你在async异步函数外使用它，会抛出语法错误。

  async/await的目的是简化使用多个 promise 时的同步行为，并对一组 Promises执行某些操作。正如Promises类似于结构化回调，async/await更像结合了generators和 promises。

例如,如下代码：

    function test1() {return new Promise((resolve, reject) => {resolve(123);})}function test2() {return new Promise((resolve, reject) => {test1().then(data => { //test1返回的值：123  即data=123;console.log(data); //123;resolve();})})}test2()等价于：async function test1() {return 123}async function test2() {const result = await test1(); //test1 return返回出来的是123 console.log(result); //123}test2();

注意：
  如果await后面不是一个promise，则直接输出await后面的语句

	例如：async function test() {const result = await 1;console.log(result); // 输出：1}test();等同于async function test1() {return new Promise((resolve, reject) => {Promise.resolve(1).then(data => { //推出的值为1，所以data的值也为1；const result = data;console.log(result);  // 输出：1resolve();})})}test1();小结：如果await表达式后面不是promise，则会对包装一个promise继续按照规则执行。

2.迭代器

什么是迭代器？
  迭代器是一个统一的接口，也可以叫遍历器。
  它的作用是使各种数据结构可被便捷的访问，它是通过一个键为Symbol.iterator 的方法来实现。

  Iterator 函数返回一个对象，它实现了遗留的迭代协议，并且迭代了一个对象的可枚举属性。
  生成器创建的所有迭代器都是可迭代对象，因为生成器默认就会为 Symbol.iterator 属 性赋值。

  可以使用 Symbol.iterator 来访问对象上的默认迭代器，如下：

	let values = [1, 2, 3];let iterator = values[Symbol.iterator]();console.log(iterator.next()); // "{ value: 1, done: false }"console.log(iterator.next()); // "{ value: 2, done: false }"console.log(iterator.next()); // "{ value: 3, done: false }"console.log(iterator.next()); // "{ value: undefined, done: true }"

可迭代对象的必须存在[Symbol.iterator]方法，该方法一个无参函数，返回迭代器协议的对象。

迭代器对象包含一个next()函数，该函数返回值有两种:

• 如果迭代未结束，返回如下

   return {value: 'item', // item是本次迭代值，可以为任意对象done: false}
  

• 如果迭代已结束，返回如下

   return {done: true}
  

举个数组的迭代器例子，如下：

 	var arr1 = [1, 2, 3, 4, 5];var arr2 = [6, 7, 8, 9, 10]function createIterator(arr) {let i = 0;return {next() {var result = {value: arr[i],done: i >= arr.length,}i++;return result}}}const iter1 = createIterator(arr1);iter1.next() // {value: 1, done: false}iter1.next() // {value: 2, done: false}iter1.next() // {value: 3, done: false}iter1.next() // {value: 4, done: false}iter1.next() // {value: 5, done: false}//当迭代结束时，值为undefined，done为trueiter1.next() //{value: undefined, done: true}

迭代和遍历的区别？
  迭代强调的依次取出，不能确定可以取出的值有多少，也不能保证去吧数据全部取完。
  遍历必须保证数据的长度，循环不断的全部取出，针对于数据量过大的情况下使用遍历需要时间过长。

再看一下使用迭代器创建斐波那契数列：

    function cre() {let arr = [0, 1];let i = 1;return {next() {if (arr[i] == undefined) { //如果arr[i]的值不存在于arr数组则为undefined// 则将数据添加到arr数组中arr.push(arr[i - 1] + arr[i - 2]);}let value = arr[i];i++;return value}}}const item = cre(); item.next(); // 1item.next(); // 1item.next(); // 2item.next(); // 3...

3.生成器

什么是生成器？
  生成器就是通过构造函数genertaor创造出来的对象，生成器既是一个迭代器，同时也是一个可迭代对象

基本语法:function *函数名(){数据;yield 值（可有可无）}使用：函数名.next()使用next方法后会返回一个对象，这个对象就是迭代对象，对象中的value值就是yield后面的值。另外：function* test(){ //表示当前函数变成generator函数}

注意：

  generator类似于阻断器，如果函数中没有yield，则函数中的所有数据会一次性输出，如果每条数据下有yield,则每调用一次则输出一次。
  生成器中关键字 yield 只能在函数内部使用，表示产生一个迭代数据。

如下：

    function* test() {console.log(1);console.log(2);yield 2;console.log(3);yield 3;}const generator = test() ；console.log(generator)；//第一次调用generator.next() //输出：12{value: 2, done: false}//第二次调用generator.next() //输出：{value: 3, done: false}//第三次调用generator.next() //输出：{value: undefined, done: true}

同样的，使用生成器创建一个斐波那契数列：

    function* test() {let arr = [0, 1];let i = 1;while (true) {if (arr[i] == undefined) {arr.push(arr[i - 1] + arr[i - 2]);}let value = arr[i];i++;yield value;}}const tst = test()item.next(); // 1item.next(); // 1item.next(); // 2item.next(); // 3...

注意点：
  1.生成器有返回值，出现在最后一次的done为true。
  2.调用生成器中的next方法时，可以传递参数，传递的参数可以交给yeild表达式的返回值。
  3.第一次去调用函数时，传递的参数是没有任何含义的。

常用API：
  1.return 调用以后，提前结束生成器函数，这个迭代过程也提前结束

    function *test(){yield 1;yield 2;yield 3;return 4;}const generator = test()generator.next() // {value: undefined, done: true}generator.next() // {value: undefined, done: true}generator.return() // {value: undefined, done: true} 直接提前结束 

  2.throw 可以在生成器产生一个错误，抛出到对应的行中去。

    function *test(){yield 1;yield 2;yield 3;return 4;}const generator = test()generator.next() generator.throw(new Error("qwe"))//直接返回一个错误 Uncaught Error: qwe