Generator 函数的定义
语法上,Generator 函数是一个状态机,封装了多个内部状态。
形式上,Generator是一个函数。不同于普通函数,是可以暂停执行的,所以函数名之前要加星号,以示区别。
整个Generator函数就是一个封装的异步任务,或者说是异步任务的容器,异步操作需要暂停的地方,都用yield语句。
什么是Generator函数
- function 关键字和函数之间有一个星号(*),且内部使用yield表达式,定义不同的内部状态。
- 调用Generator函数后,该函数并不执行,返回的也不是函数运行结果,而是一个指向内部状态的指针对象。
function* fn(){ // 定义一个Generator函数
yield ‘hello’;
yield ‘world’;
return ‘end’;
}
var f1 =fn(); // 调用Generator函数
console.log(f1); // fn {[[GeneratorStatus]]: “suspended”}
console.log(f1.next()); // {value: “hello”, done: false}
console.log(f1.next()); // {value: “world”, done: false}
console.log(f1.next()); // {value: “end”, done: true}
console.log(f1.next()); // {value: undefined, done: true}
但是,调用Generator函数后,函数并不执行,返回的也不是函数执行后的结果,而是一个指向内部状态的指针对象。
下一步,必须调用遍历器对象的next方法,使得指针移向下一个状态。即:每次调用next方法,内部指针就从函数头部或上一次v执行的标记,而next方法可以恢复执行。
如下案例:
function* gen(x){//一个 Generator 函数
console.log('x='+x)
var y = yield x + 2;
return y;
}
//调用Generator 函数
var g = gen(1);
g.next();
输出:x=1
{value: 3, done: false}
注意:调用g.next() 即执行异步任务的 x+2
next 方法的作用是分阶段执行 Generator 函数。每次调用 next 方法,会返回一个对象,表示当前阶段的信息( value 属性和 done 属性)。
value 属性是 yield 语句后面表达式的值,表示当前阶段的值;
done 属性是一个布尔值,表示 Generator 函数是否执行完毕,即是否还有下一个阶段(done为false 继续执行)。
Generator 函数的数据交换
function* gen(x){
var y = yield x + 2;
return y;
}
var g = gen(1);
//第一次执行
g.next() // { value: 3, done: false }
//第二次执行 时,如果有带参数,
这个参数可以传入 Generator 函数,作为上个阶段异步任务的返回结果,被函数体内的变量 y 接收。
g.next(2) // { value: 2, done: true }
因此,这一步的 value 属性,返回的就是2(变量 y 的值)。
//如果没带参数
g.next() //{value: undefined, done: true}
1.迭代器协议: 定义了一种标准的方式来产生一个有限或无限序列的值;
当一个对象被认为是一个迭代器时,它实现了一个 next() 的方法,next()返回值如下:
{
done:true,//false迭代是否结束,
value:v,//迭代器返回值
}
2.generator的用途:
在JavaScript中,一个函数一旦被执行,就会执行到最后或者被return,运行期间不会被外部所影响打断,而generator的出现就打破了这种函数运行的完整性。
3.generator函数与普通函数的区别:
a.function关键字与函数名中间有一个*键
b.Generator函数使用了yield表达式
c. 直接调用 Generator函数并不会执行,也不会返回运行结果,而是返回一个遍历器对象(Iterator Object)
d.调用Generator函数时需用到next(),如果有多个yield状态,要依次调用next()
e.该生成器函数执行后会返回一个Iterator对象,对象内有yield的返回值,以及还有一个状态done的属性(该属性表示当前生成器内yield表达式全部执行完毕,执行完毕返回true)
{
done:true,//false迭代是否结束,
value:v,//迭代器返回值
}
4.generator函数的语法:
// 传统函数
function foo() {
return 'hello world'
}
foo() // 'hello world',一旦调用立即执行
//Generator函数
function* persition(){
yield '我是generato生成器';
yield '我要开始了';
return '结束'
}
//创建一个句柄,赋值给生成器
var iterator =persition();
//直接调用并不能被立即执行
console.log(iterator)
//需使用next()方法来调用这个生成器 next()方法调用一次,
//并不能将Generator函数内的yield值全部打印出来,需要依次进行调用
console.log(iterator.next())
console.log(iterator.next())
//如果iterator对象内done为true,证明Generator函数执行完毕
console.log(iterator.next())
5.yield表达式:
yield 表达式只能用在 Generator 函数里面,用在其它地方都会报错
function(){
yield 1;
}
// SyntaxError: Unexpected number
// 在一个普通函数中使用yield表达式,结果产生一个句法错误
}
6.next():
generator函数(生成器)调用的唯一方法,且注意需依次调用next方法,
对于普通的生成器,第一次next调用,相当于启动生成器,会从生成器函数的第一行代码开始执行,直到第一次执行完yield语句后,跳出生成器函数。
然后第二个next调用,进入生成器函数后,从yield语句的下一句语开始执行,然后重新运行到yield语句,执行后,跳出生成器函数,
promise generator aysnc/await
1.三者都是异步编程的解决方案,不同的是,promise为较早出来的,其次generator,最后为async/await,三者象征了前端进行解决异步编程的进化路程。
promise:
promise比较简单,也是最常用的,主要就是将原来用 回调函数异步编程的方法 转成 relsove和reject触发事件;
对象内含有四个方法,then()异步请求成功后
catch()异步请求错误的回调方法
finally()请求之后无论是什么状态都会执行
resolve()将现有对象转换为Promise对象
all()此方法用于将多个Promise实例包装成一个新的promise实例。
race()也是将多个Promise实例包装成一个新的promise实例
reject()返回一个状态为Rejected的新Promise实例。
有点:让回调函数变成了规范的链式写法,程序流程可以看的很清楚
缺点:编写的难度比传统写法高,阅读代码也不是一眼可以看懂
Generator:
generator是一个迭代生成器,其返回值为迭代器(lterator),是ES6标准引入的新的数据类型,主要用于异步编程,它借鉴于Python中的generator概念和语法;
generator函数内有两个重要方法,1 yield表达式 2.next()
Generator 函数是分段执行的,yield表达式是暂停执行的标记,而 next方法可以恢复执行
优点:1.利用循环,每调用一次,就使用一次,不占内存空间 2.打破了普通函数执行的完整性
缺点: 需要用next()方法手动调用,直接调用返回无效iterator 2.
async/await:
async:异步函数
await:同步操作
es7中提出来的异步解决方法,是目前解决异步编程终它基极解决方案,于promise为基础,其实也就是generator的高级语法糖,本身自己就相当于一个迭代生成器(状态机),它并不需要手动通过next()来调用自己,与普通函数一样
async就相当于generator函数中的*,await相当于yield,
async 用于申明一个 function 是异步的,而 await 用于等待一个异步方法执行完成。
function getSomething() {
return "something";
}
async function testAsync() {
return Promise.resolve("hello async");
}
async function test() {
//await是在等待一个async函数完成
const v1 = await getSomething();
//await后面不仅可以接Promise,还可以接普通函数或者直接量
const v2 = await testAsync();
console.log(v1, v2);
}
运用场景
1、代替递归
斐波那契数列的实现:
function * fibonacci(seed1, seed2) {
while (true) {
yield (() => {
seed2 = seed2 + seed1;
seed1 = seed2 - seed1;
return seed2;
})();
}
}
const fib = fibonacci(0, 1);
fib.next(); // {value: 1, done: false}
fib.next(); // {value: 2, done: false}
fib.next(); // {value: 3, done: false}
fib.next(); // {value: 5, done: false}
fib.next(); // {value: 8, done: false}
2、异步操作的同步化
Generator 函数的暂停执行的效果,意味着可以把异步操作写在yield表达式里面,等到调用next方法时再往后执行。这实际上等同于不需要写回调函数了,因为异步操作的后续操作可以放在yield表达式下面,反正要等到调用next方法时再执行。所以,Generator 函数的一个重要实际意义就是用来处理异步操作,改写回调函数。
Ajax 是典型的异步操作,通过 Generator 函数部署 Ajax 操作,可以用同步的方式表达。
function* main() {
var result = yield request(“http://some.url“);
var resp = JSON.parse(result);
console.log(resp.value);
}
function request(url) {
makeAjaxCall(url, function(response){
it.next(response);
});
}
var it = main();
it.next();
上面代码的main函数,就是通过 Ajax 操作获取数据。可以看到,除了多了一个yield,它几乎与同步操作的写法完全一样。注意,makeAjaxCall函数中的next方法,必须加上response参数,因为yield表达式,本身是没有值的,总是等于undefined。
逐行读取文本文件:
function * numbers() {
let file = new FileReader(“numbers.txt”);
try {
while(!file.eof) {
yield parseInt(file.readLine(), 10);
}
} finally {
file.close();
}
}
3、控制流的管理
如一个多步操作非常耗时,采用回调的话:
step1(function (value1) {
step2(value1, function(value2) {
step3(value2, function(value3) {
step4(value3, function(value4) {
// Do something with value4
});
});
});
});
采用promise改写:
Promise.resolve(step1)
.then(step2)
.then(step3)
.then(step4)
.then(function (value4) {
// Do something with value4
}, function (error) {
// Handle any error from step1 through step4
}).done();
而使用generator函数:
function* longRunningTask(value1) {
try {
var value2 = yield step1(value1);
var value3 = yield step2(value2);
var value4 = yield step3(value3);
var value5 = yield step4(value4);
// Do something with value4
} catch (e) {
// Handle any error from step1 through step4
}
}
总结:
从回调函数,到promise,再到generator,再到Async/await,这四种分别代表了JavaScript异步编程解决方案的进化路程。async和generator函数主要就是为了解决异步的并发调用使用的 ,直接将参数从then里取出来,相比promise的链式调用,传参更加方便,异步顺序更加清晰