Promise关键字async、await以及迭代器和生成器

1.async关键字使用

        将async当成函数修饰符来使用，放在函数的开始位置，并且被async修饰的函数会返回一个Promise对象

        注意点：1.如果async有错误的时候，可以使用try... catch  来捕获错误

                      2.自己返回的Promise,以自己的为主

   写法和使用方法:

 <script>
        function xunwen(txname){
            return new Promise((resolve,reject) =>{
                console.log(`小明向${txname}发送了晚餐请求`)
                setTimeout(() =>{
                    if(Math.random() < 0.1){
                        resolve(true)
                    }else{
                        resolve(false)
                    }
                })
            },2000)
        }

        async function xunwen2(txname){
            console.log(`小明向${txname}发送了晚餐请求`)
            const pro = setTimeout(() =>{
                if(Math.random() < 0.5){
                    return true;
                }else{
                    return false;
                }
            },500)
        }
       
    </script>

2.await关键字使用

        相当于then方法，并且await关键字必须写在async函数中，如果await等到的不是一个Promise对象，那await表达式的运算结果就是表达式里的值。如果await等到的是一个Promise对象,那么它会阻塞后面的代码，等着Promise里面resolve里的值，然后得到resolve的值，作为await表达式的结果。

        注意：如果await关键字后面不是一个Promise对象，则直接输出await后面的语句。

        写法和使用方法：

 <script>
        function xunwen(txname){
            return new Promise((resolve,reject)=>{
                console.log(`史继业向${txname}发送晚餐请求`)
                setTimeout(()=>{
                    if(Math.random() < 0.1){
                        resolve(true)
                    }else{
                        resolve(false)
                    }
                },500)
            })
        }
   
        (async ()=>{
            for(let i = 1;i < 26;i++){
                const result = await xunwen(`同学${i}`)
                if(result){
                    console.log(`${i}同意了`)
                    break
                }else{
                    console.log(`${i}拒绝了`)
                }
            }
        })()
    </script>

3.迭代器   iterator

     迭代的解释：从一个数据集合中按照一定的顺序，不断取出数据的过程

     迭代器的解释：对迭代过程的封装，通常表现为对象的数据形式（也有数组的形式），不同的语言中，表现出来的形式是不一样

     满足条件：1.有得到下一个数据的能力

                       2.判断是否有后续数据的能力

     注意：1.ES6之后数组对象Array就已经有迭代器的方法，可以直接使用,在ES6之后，如果对象原型上具有知名符号属性Symbol.iterator方法，则表示该对象可迭代。

                2.扩展运算符（...）的展开功能只能在可迭代对象上使用

4.生成器  generator

        生成器的解释：生成器就是通过构造函数Genterator创建出来的对象，生成器就是一个迭代器，同时又是一个可迭代对象

        如何创建：只需要把函数写成Generator函数，然后加上修饰符*

        作用：控制函数内部代码的执行

   注意：1.生成器有返回值，出现在最后一次done为true的value值

              2.调用生成的next()方法是可以传递参数,传递的参数会交给yield表达式上的返回值

              3.第一次调用next函数的时候，传递的参数是没有任何含义的

5.迭代器和生成器演示代码(斐波拉契数列)

 <script>
        // 斐波那契数列迭代器
        // 1 1 2 3 5 8 13 21 34
        function createFeiboIterator(){
            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
                    }
                    prev1 = prev2;
                    prev2 = result.value;
                    n++;
                    return result;
                }
            }
        }
        const iterator = createFeiboIterator()


            斐波那契数列生成器
         function* createFeibo(){
             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++;
             }
         }
         let gener = createFeibo()
         gener.next()
    </script>