es6迭代器和生成器

迭代器

1.什么是迭代？
从一个数据集合中按照一定的顺序，不断取出数据的过程
2.迭代和遍历有什么区别？
迭代强调的是依次取出，不关心能够取出多少数据，也不保证能数据全部取完
遍历必须知道数据长度，循环不断取出，直到数据取完为止
3.迭代器
对迭代过程的封装,通常表现形式为对象
4.迭代模式
一种设计模式，用于统一迭代的过程，并且规范迭代器的规格
1. 迭代器有得到下一个数据的能力
2. 判断是都有后续数据的能力
js对于迭代器的规定，如果一个对象具有next方法，并且next方法返回一个对象，则认为该对象为迭代器

const str=[1,2,3,456,6,234,2134]
function creatStr(str){
let i=0;
    return{
        next(){
            var result={
                value:str[i],
                done:this.i>=str.length
            }
            i++;
            return result;
        
        }
    }
}
const lt=creatStr(str);
console.log(lt.next());

斐波拉契数列迭代器

  function createFeobo(){
            let prev1 = 1;
            let prev2 = 1;
            let n = 1;
            return {
                next(){
                    let value;
                    if(n <= 2){
                        value = 1
                    }else{
                        value = prev1 + prev2
                    }
                    const result = {
                        value,
                        done : false
                    }
                    prev2 = prev1;
                    prev1 = result.value;
                    n++;
                    return result
                }
            }
        }
        const iter1 = createFeobo()
       console.log( iter1.next())

ES6对于数组对象增加了迭代器的方法，可以直接使用

const str=[1,2,3,4,5,12,31,5]
const a=str[Symbol.iterator]()
console.dir(a.next())

forin一般用来遍历对象，forof只能遍历可迭代对象
数组和类数组因为具有Symbol.iterator方法，所以为可迭代对象，对象没有Symbol.iterator方法则为不可迭代对象，可以在对象上面添加Symbol.iterator方法。for of可以遍历到

[Symbol.iterator] : function* (){
                const keys = Object.keys(this);
                let i = 0;
                while(i <= keys.length){
                    const propName = keys[i];
                    const propValue = this[propName];
                    yield {propName,propValue};
                    i ++;
                }
            }

生成器

1.什么是生成器？
生成器就是通过构造函数Generator构造出来的对象，生成器本身是一个迭代器，同时又是一个可迭代对象
2.如何创建？
new Generator() 错误的
只需要把普通函数变成generator函数
通过修饰符就可以将普通函数变成generator函数
async和修饰符不能同时使用在一个函数上面

 function *test(){}
        const generator = test()//这个对象就是一个生成器，同时也是一个迭代器，具有next方法和Symbol.iterator属性
        console.log(generator)

练习：

function* test(){
            console.log(1);
            yield 'a';
            console.log(2)
            yield 'b';
            console.log(3)
            yield 'c';
            console.log(4)
            yield 'd';
            console.log(5)
        }
        const lt=test()
        console.log(lt.next())

用生成器创造斐波拉契数列

 function *createFeobo(){
            let prev1 = 1;
            let prev2 = 1;
            let n = 1;
            while(true){
                if(n <= 2){
                    yield 1;
                }else{
                    const newValue = prev1 + prev2; 
                    yield newValue;
                    prev1 = prev2;
                    prev2 = newValue;
                }
                n++;
            }
        }
        const iter = createFeobo()

在函数内调用另外一个生成器（*fun（））

 // 如何在一个生成器函数中调用另一个生成器函数
        function *fun1(){
            yield 1;
            yield 2;
        }
        function *fun2(){
            yield *fun1();
            yield "a";
            yield "b";
        }
        const g = fun2()