Promise面试题—（面试7连击）

Promise面试7连击

1. 什么是回调函数

    所谓的回调函数就是参数的传递，在一个函数内部调用另一个函数，调用的同时可以把内部函数的数据传递出来。
   

    //回调函数
    function getData(callback){
        setTimerout(function(){
            var a = 1
            callback(a)
        },1000)
    }

    getData(function (res){
        console.log(res)
    })

2. 回调函数的使用场景

    当异步请求的时候无法立刻获取到具体的值。
   

3. 回调函数多层嵌套的时候存在什么问题

    层层的回调函数，嵌套层级多了后，就形成了回调地狱，代码的可阅读性很差。
   

4. 如何解决回调地狱

    用promise来解决回调地狱的，把回调函数的主从关系，变成并列关系。
   

5. 使用promise 解决回调地狱

    const fs = require('fs');

    function getData(path){
        return new Promise(resolve,reject)=>{
            fs.readFile(path,'utf-8',(err,data)=>{
                if(err) return reject(err)
                resolve(data)
            })
        }
    }

    //当前的.then处理上一次的请求，使用promise可以把异步的请求方式按照同步的方式执行
    getData('./file/1.txt')
        .then(res=>{
            console.log(res)
            return getData('./file/2.txt')
        })
        .then(res=>{
            console.log(res)
            return getData('./file/3.txt')
        })
        .then(res=>{
            console.log(res)
        })

6. promise 的特性

   promise 是一个构造函数，也是一个对象。

   promise的原型函数then：

       fnA().then(fnB).then(fnC)  
   

   promise对象（异步操作）有三种状态：

​ Pending：进行中

​ Resolved（Fulfilled）：已完成（成功）

​ Rejected：已失败

以上三种状态的改变不受外界的影响，只由异步操作本身影响。

​     状态变化有两种情况：

​     1）、由pending 变成  Resolved

​     2）、由pending 变成  Rejected

7. promise 有什么缺点，如何解决

   缺点：
   1) 无法取消 Promise

    2) 当处于pending状态时，无法得知目前进展到哪一个阶段
    
    3) 代码量增多 
   

   解决方案：

    1). Promise.all  Promise.race
   
    ```js
   
        // 返回存储在 promise对象的所有结果 
        Promise.all([getData('./file/1.txt'),getData('./file/2.txt'),getData('./file/3.txt')]).then(res=>{
            console.log(res);
        })
   
        // 谁执行最快打印谁的结果，其他不执行
        Promise.race([getData('./file/1.txt'),getData('./file/2.txt'),getData('./file/3.txt')]).then(res=>{
            console.log(res);
        })
   
    ```
   
    2). 使用es7 的 async await  
   
        async和await是ES7出现关键字，目的是彻底解决回调地狱，比Promise彻底。即就是：把异步的回调变成了同步的写法。
   
        await是等待的意思，await修饰的代码会等待。在函数里，碰到await修饰的代码时，await朝后的代码都会等待。 等到函数外面的代码执行完毕后，再执行await里的代码。
   
        语法：
        ```js
            async function getFileData(){
                const data1 = await getData('./file/1.txt');
                const data2 = await getData('./file/2.txt');
                const data3 = await getData('./file/3.txt');
   
                console.log(data1);
                console.log(data2);
                console.log(data3);
            }
        ```
        + ps: await只能写在async修饰的函数里。
   

   • 处理promise的错误捕获 try catch

       格式：
     

   
           try{
   
           ​     //若干句代码；这些代码里，只要碰到错误，就会跳到catch里。即就是：碰到错误后，try里处于错误行后面的代码不再执行。
   
           }catch(){
   
           ​    //出错
   
           }