美文网首页
ES6 Generator

ES6 Generator

作者: 会飞的猪l | 来源:发表于2017-08-24 17:03 被阅读9次

Generator函数是协程在ES6的实现,最大的特点就是可以交出函数的执行权(即暂停执行)。
Generator函数和普通函数区别有两个,
1:function和函数名之间有一个*号,
2:函数体内部使用了yield表达式;比如这样:

function *gen(){
           yield '1';
           yield '2'; 
           return '3';
}

整个Generator函数就是一个封装的异步任务,或者说是异步任务的容器。异步操作需要暂停的地方,都用yield语句注明。Generator函数的执行方法如下。

var g = gen();
g.next(); //{value: 1 ,done:fasle}
g.next(); //{value: 2 ,done:fasle}
g.next(); //{value: 3 ,done:true}

上面的代码中,调用Generator函数,会返回一个内部指针(即遍历器)g。这是Generator函数不同于普通函数的另一个地方,即执行它不会返回结果,返回的是指针对象。调用指针g的next()方法,会移动指针,指向第一个遇到的yield语句。并且将yield的参数返回给next这个方法的value。再次调用就会执行第二个yield语句,返回它的参数。
可以看到next方法返回2个参数,一个是value,一个是done,第一个value就是yield的参数,第二个就是表示遍历是否结束。以上代码它让retrun了,所以代码结束,返回true。
yield配合字符串输出的话必须要加一个(),比如

function *gen(){
console.log('hello'+(yield));
console.log('hello'+(yield 123));
} 

next方法可以进行传参
yield表达式本身没有返回值,或者说总是返回undefined。next方法可以带一个参数,该参数就会别当成yield的返回值。比如

function* gen(x){
var y = 2 * (yield(x+ 1));
var z = yield (y/3);
return (x+y+z);
}
var a = gen(5);
a.next()  // value: 6;
a.next()  // value:NaN;
a.next()  // value:NaN;
var b = gen(5);
b.next(); // value:6;
b.next(12); //value :8
b.next(13);//value:42 

上面代码中,第二次运行next方法的时候不带参数导致y返回undefined,2undefined,所以返回NaN,后一个同理。
如果在next中传入参数,第一个x+1 = 6;返回6,第二个next传参12,2
12 = 24;24/3 = 8;返回8,第三个next传参13, 5 + 24 + 13 = 42。返回42。

Generator可以通过for...of遍历,遍历不再需要next方法。

function *gen(){
yield 1;
yield 2;
yield 3;
yield 4;
yield 5;
return 6;
}

for(let v of gen()){
console.log(v);//1 2 3 4 5 
}

上面代码使用for...of循环,依次显示5个yield表达式的值,这里需要注意一下,一旦next方法的返回对象的done属性为true,for...of循环就会中止。且不包含该返回对象,所以上面代码retrun 6,不包括在for...of循环之中。
除了for...of循环之外,扩展运算符(...)、解构赋值和array.from方法内部调用的,都是遍历器接口。这意味着,它们都可以将Generator函数返回的Iterator对象,作为参数。

function *gen(){
yield 1;
yield 2;
return 3;
yield 4;
}

//   扩展运算符
[...gen()]   //  [1,2]

//  Array.from 方法
Array.from(gen());  // [1,2]

//  解构赋值
let [x,y] = gen();
x  // 1
y  //  2 

//   for...of  循环
for(let v of gen()){
console.log(n);
//    1
//    2
}

Generator函数返回的遍历器对象,都有一个throw方法,可以在函数体外抛出错误,然后在Generator函数体内捕获。

var g = funciton* (){
try{
  yield;
} catch(e){
console.log('内部捕获',e)
}
}

var i = g();
i.next();

try{
 i.throw('a');
i.throw('b');
} catch(e){
console.log('外部捕获',e);
}
// 内部捕获 a
// 外部捕获 b

上面代码中,遍历器对象i连续抛出两个错误。第一个错误被Generator函数体内的catch语句捕获。i第二次抛出错误,由于Generator函数内部的catch语句已经执行过啦,不会再捕获这个错误啦,所以这个错误就被抛出了Generator函数体,被函数体外的catch语句捕获。

Generator函数返回的遍历器对象,还有一个return的方法,可以返回给定的值,并且终结遍历Generator函数。

funciton *gen(){
  yield 1;
  yield 2;
  yield 3;
}

var g = gen();
g.next(); // value 1 done :false
g.return('foo') // value 2 done :false
g.next()  // value :undefined done :true

上面的代码中,遍历器对象g调用retrun方法后,返回值的value属性就是retrun方法的参数foo。并且Generator函数的遍历就终止了,返回值的done属性为true,以后再调用next方法,done属性总是返回true。 如果retrun没有传参,那么返回的value就是undefined。
如果Generator函数内部有try...finally代码块,那么retrun方法会推迟到finally代码块执行完在执行。

funciton* gen(){
yield 1;
  try{
      yield 2;
      yield 3;
  } finally{
    yield 4;
    yield 5;
  }
yield 6;
}

var g = gen();
g.next(); // value :1 done :false
g.next(); // value :2 done :false
g.reture(7); // value :4 done :false
g.next(); // value :5 done :false
g.next(); // value :7 done :true

上面代码中,调用retrun方法后,就开始执行finally代码块,然后等到finally代码块执行完,在执行retrun方法。

yield* 表达式
假如foo和bar都是Generator函数,在bar里面调用foo,是不会有效果的。
这个就需要用到yield*表达式,用来在一个Generator函数里面执行另一个Generator函数

funciton* bar(){
      yield 'x';
      yield* foo();
      yield 'y';
}

//等同于
funciton* bar(){
    yield 'x';
    yield 'a';
    yield 'b';
    yield 'y';
}

//等同于
function* bar(){
  yield 'x';
  for(let v of foo()){
    yield v;
  }
  yield 'y';
}

for(let v of bar()){
  console.log(v);
}
// 'x'
// 'a'
// 'b'
// 'y'

yield* 后面的Generator函数(没有retrun语句时),等同于在Generator函数内部,部署一个for...of循环。

function *concat(item1,item2){
  yield* item1;
  yield* item2;
}

// 等同于
function* concat(item1,item2){
  for(var value of item1){
      yield value;
  }
  for(var value of item2){
      yield value;
  }
}

如果yield*后面跟着一个数组,由于数组原生支持遍历器,因此就会遍历数组成员。

function* gen(){
  yield* [1,1,1,2,3,3,5];
}
gen().next()  // value 1;

上面代码中,yield命令后面如果不加星号,返回的是整个数组,加了星号之后返回的就是数组遍历的对象。

相关文章

网友评论

      本文标题:ES6 Generator

      本文链接:https://www.haomeiwen.com/subject/jnhedxtx.html