第一次接触到yield这个关键字是在Python里面。伴随着Generator和Comprehension了解到的。当时一直没觉得它多重要，还以为它只是个另外一个用起来放便点的语法糖。后来接触了ES6，接触了co，我才意识到，这是个了不得的东西。
Python的Generator
Python对「Comprehension」的支持非常友好，相同的语法，可以用在List Comprehension, Set Comprehension, Dict Comprehension, Generator……
[i * 2 for i in range(10) if i ** 2 < 10]
#> [0, 2, 4, 6]
{i * 2 for i in range(10) if i ** 2 < 10}
#> {0, 2, 4, 6}
{k.upper(): v for k, v in {"a": 1, "b": 2}.items()}
#> {'A': 1, 'B': 2}
(i * 2 for i in range(10) if i ** 2 < 10)
#> <generator object <genexpr> at 0x7f9c53a99410>
上例中的最后一个，就是所谓的Generator。它还有另外一种产生方法。先定义一个特殊的函数
def blah():
for i in range(10):
if i ** 2 < 10:
yield i * 2
然后就可以用如下方法产生一个Generator
blah()
#> <generator object blah at 0x7f9c53a99410>
通过__next__方法，我们可以看到，Generator以一种极为怪异的方式运作。最简单的理解方式，是把yield看作一个特殊的return，它们在某种程度上的确相似。
a = blah()
a.__next__()
#> 0
a.__next__()
#> 2
a.__next__()
#> 4
a.__next__()
#> 6
a.__next__()
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# StopIteration
看上去很怪异，因为「Generator function」和「function」根本就是两种不同的东西。而在Python里，却使用同样的语法def name():来创建它们。
调用「Generator function」返回的是一个Generator对象，而不是那个“函数”的执行结果。
Javascript的Generator
在这一点上，Javascript比Python做得好。引入Generator的时候，Javascript定义了一个新的关键字function*，两者就被显式地区分开了。你一眼就能注意到，这不是一个普通的函数。
我觉得这是少数Javascript做得比Python好的地方。
function* blah() {
for (var i = 0; i < 10; i++)
if ((i * i) < 10)
yield i * 2
}
和Python一样，通过一个特定的方法（next）来使用
a = blah()
//> Generator { }
a.next()
//> Object { value: 0, done: false }
a.next()
//> Object { value: 2, done: false }
a.next()
//> Object { value: 4, done: false }
a.next()
//> Object { value: 6, done: false }
a.next()
//> Object { value: undefined, done: true }
对参数的支持情况
Generator的next方法支持参数这一点非常重要，它是让Generator能够包装异步调用的基础特性。JS里面，继续使用next就行了。
function* blah() {
for (var i = 0; i < 10; i++) {
t = yield i * 2
console.log('t is ', t)
}
}
传递参数给next，就仿佛是赋值给那个yield表达式一样。
a = blah()
//> Generator { }
a.next("a")
//> Object { value: 0, done: false }
a.next("b")
// t is b
//> Object { value: 2, done: false }
a.next("c")
// t is c
//> Object { value: 4, done: false }
Python的__next__不支持这种特性
def blah():
for i in range(10):
t = yield i * 2
print('t is ', t)
当你给__next__传递参数的时候
a = blah()
a.__next__(1)
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: expected 0 arguments, got 1
然而Python的Generator有个叫做send的方法，它可以完成这个工作。send必须传一个参数，而且初次调用必须传None。所以细节上和JS有点区别，但大体上是一致的。
a = blah()
a.send(None)
#> 0
a.send("b")
# t is b
#> 2
a.send("c")
# t is c
#> 4
至于为什么不把__next__和send合并为一个就不得而知了。其实跳出来看看，对应Generator的行为，取名叫send的确更合语境。
异常与Generator
对于Generator而言，在next之外，最重要的一个方法就是throw了。在Generator函数里面，异常是可以被捕获的，即使异常的发生地点不在本函数内部。这是Generator的一大特点。
Javascript和Python在异常的处理这块出奇的一致，名字都一样使用throw。
为了方便，先写一个永远返回"ok"的Generator函数
var cnt = 0
function* blah() {
while (true) {
try { yield ++cnt }
catch (e) { console.log(`error: ${e.message}`) }
}
}
现在对它做点测试
a = blah()
a.next()
//> Object {value: 1, done: false}
a.next()
//> Object {value: 2, done: false}
a.next()
//> Object {value: 3, done: false}
a.throw(new Error("haha"))
// error: haha
//> Object {value: 4, done: false}
a.throw(new Error("haha"))
// error: haha
//> Object {value: 5, done: false}
a.next()
//> Object {value: 6, done: false}
Python如何呢，同样的实验
cnt = 0
def blah():
global cnt
while True:
try:
cnt += 1
yield cnt
except Exception as e:
print("error:", str(e))
同样的测试
a = blah()
a.__next__()
#> 1
a.__next__()
#> 2
a.__next__()
#> 3
a.throw(Exception("haha"))
# error: haha
#> 4
a.throw(Exception("haha"))
# error: haha
#> 5
a.__next__()
#> 6
