一、迭代器Iterator
迭代器是访问数据的一个接口，是用于遍历数据结构的一个指针，迭代器就是遍历器
const items=['one','two','three'];
//创建新的迭代器
const it=items[Symbol.iterator]();
console.log(it.next());
done：返回false表示遍历继续，返回true表示遍历完成
二、生成器Generator
1.generator
generator函数可以通过yield关键字将函数挂起来（只能在函数内部使用）。
它跟普通函数的区别是，他得在function后面加*，调用该函数将会返回一个遍历器对象
generator函数是分段执行的，遇到yield就暂停执行，而next（）是恢复执行，把你上一个结果给你返回出来
function* func(){
console.log('start');
const x=yield '2';
console.log('continue'+x);
const y=yield '3';
console.log('continue'+y);
console.log(x+y);
return x+y;
}
const fn=func();
console.log(fn.next());
console.log(fn.next(2));
console.log(fn.next(3));
console.log(fn.next());
x它不是yield的返回值，它是当next调用，恢复当前yield传入的实参
（1）遇到yield表达式，就暂停执行后面的操作，并将紧跟在yield后面的那个表达式的值，作为返回的对象的value属性值。
（2）下一次调用next方法时，再继续往下执行，直到遇到下一个yield表达式。
（3）如果没有再遇到新的yield表达式，就一直运行到函数结束，直到return语句为止，并将return语句后面的表达式的值，作为返回的对象的value属性值。
（4）如果该函数没有return语句，则返回的对象的value属性值为undefined。
所以遇到第一个next的时候，start先输出，然后直接到了第一个yield 2，直接输出2
第二个next，传入了实参2，被x接收，输出continue2，又遇到了yield，直接输出后面的3
第三个next，传入了实参3，被y接收，后面输出x加y为5，然后直接ruturn了5（ruturn输出的效果和yield一样{}
最后的next后面都没有东西了，输出undefined done完成
function* foo(x) {
var y = 2 * (yield (x + 1));
var z = yield (y / 3);
return (x + y + z);
}
var a = foo(5);
a.next() // Object{value:6, done:false}
a.next() // Object{value:NaN, done:false}
a.next() // Object{value:NaN, done:true}
var b = foo(5);
b.next() // { value:6, done:false }
b.next(12) // { value:8, done:false }
b.next(13) // { value:42, done:true }
再来一个例子，就是每次返回的时候都是yield后面的值，传参数的时候都是给上一个yield，比如说y=2*yield、、、，传12的时候就是2*12
再比如传13的时候就是z=yield、、、，就是z=13
function* dataConsumer() {
console.log('Started');
console.log(`1. ${yield}`);
console.log(`2. ${yield}`);
return 'result';
}
let genObj = dataConsumer();
genObj.next();
// Started
genObj.next('a')
// 1. a
genObj.next('b')
// 2. b
yield每次后面都没有值，所以没有返回{}啥的
2.使用场景：
（1）为不具备iterator 接口的对象提供遍历操作
之前说有Symbol.iterator接口的就可以进行遍历，那么没有这个接口的怎么进行遍历呢？
function* func(obj){//来构建一个让它有接口用
const ks=Object.keys(obj);
//获取对象当中所有的k保存到数组[name,age]
for(const k of ks){
yield [k,obj[ks]];
}
}
const obj={
name:'ttt',
age:18
}//这个对象就是一个没有iterator接口的对象
obj[Symbol.iterator]=func;
console.log(obj);
for (let [key, value] of o[Symbol.iterator](o)) {
console.log(`${key}:${value}`); //name:ttt age:18
}
以上代码可以让一个没有iterator接口的对象实现遍历
弹幕说学了ajax再来看，先放一下之后再回来看
（2）让异步代码同步化
定义三个函数：加载中、加载完成、界面隐藏
如果直接调用的话，页面加载完成会最后出现，因为它是个异步
用yield将showData函数卡住，进行showData，然后在showData加了个next去输出。
function loadUI() {
console.log('页面加载中Loading......');
}
function showData() {
setTimeout(() => {
console.log('页面加载完成');
genLoad.next(); //2.页面加载完成后就立即隐藏
}, 1000);
}
function hideUI() {
console.log('页面隐藏啦');
}
function* load() {
loadUI();
yield showData();
hideUI();
}
let genLoad = load();
genLoad.next(); //1.加载页面，加载完成的时候停止
三、类的用法
promise和async打算学完ajax之后再返回来好好总结，先不往脑子里灌了
class Sum
{
constructor(x,y)
{
this.x=x;
this.y=y;
}
add(){
console.log(this.x+this.y) ;
}
}
var a=new Sum(1,4);
a.add();
类似java写法，class封装一个类，constructor（）方法是默认加进去的，不写也默认会有，通过new生成对象实例的时候会自动调用这个方法。
add（）函数前面不需要再加function。
四、类的继承
class Animal
{
constructor(name,age)
{
this.name=name;
this.age=age;
}
sayName(){
return this.name;
}
sayAge(){
return this.age;
}
}
有一个animal的类，我还想写一个dog类，包括名字年龄和颜色，其中年龄和颜色Animal都有，咱们就可以直接继承过来
class Dog extends Animal{
constructor(name,age,color)
{
super(name,age);//要继承的
this.color=color;
}
}
let t=new Dog('hh',2,'yellow');
console.log(t);
console.log(t.sayAge());//2
不仅可以继承属性，还能继承方法
class Dog extends Animal{//extends继承
constructor(name,age,color)
{
super(name,age);//super使用继承来的方法
this.color=color;
}
sayColor(){//自己的方法
return `${this.age}是${this.name}`;
}
//重写父亲的方法
sayName(){
return super.sayName();
}
}
let t=new Dog('hh',2,'yellow');
console.log(t.sayAge());//2
console.log(t.sayColor());
console.log(t.sayName());