promise的一些面试题

题目1

console.log("AAAA");
setTimeout(() => console.log("BBBB"), 1000);
const start = new Date();
while (new Date() - start < 3000) { }
console.log("CCCC");
setTimeout(() => console.log("DDDD"), 0);
new Promise((resolve, reject) => {
    console.log("EEEE");
    foo.bar(100);
})
    .then(() => console.log("FFFF"))
    .then(() => console.log("GGGG"))
    .catch(() => console.log("HHHH"));
console.log("IIII");

答案： A C E I H B D

解析

• 开始执行log，输出A
• 开启一个定时器，1s后执行t1任务
• 执行while循环，执行时间3s，这期间定时器时间到了，可以执行t1任务了，将t1任务放入宏任务队列
• 执行log，输出C
• 开启一个定时器，立即（实际不止0s）可以执行t2任务，将t2任务放入宏任务队列
• new 一个promise对象，立即执行参回调函数，执行log输出E
• 执行foo.bar(100)出错，将catch回调放入微任务队列
• 执行log，输出I
• 执行微任务输入H
• 执行红任务队列的t1，在执行t2 （队列先进先出）

题目2

async function async1() {
    console.log("AAAA");
    async2();
    console.log("BBBB");
}

async function async2() {
    console.log("CCCC");
}

console.log("DDDD");
setTimeout(function () {
    console.log("FFFF");
}, 0);

async1();

new Promise(function (resolve) {
    console.log("GGGG");
    resolve();
}).then(function () {
    console.log("HHHH");
});

console.log("IIII");

答案： D A C B G I H F

解析

• 执行log，打印D
• 开启定时任务，将t1放入宏任务队列
• 执行async1函数，打印A
• 执行asyncs函数，打印C
• 继续执行async1函数，打印B
• new 一个promise打印G，往微任务添加一个then回调函数
• 执行log，打印I
• 执行微任务，打印H
• 执行宏任务，打印F

题目3

async function t1() {
    let a = await "lagou"
    console.log(a)
}
t1()
// await 后面不是 promise 对象，直接返回对应的值


async function t2() {
    let a = await new Promise((resolve, reject) => reject()).catch(e => console.log(e))
    console.log(99); // 99
    console.log(a) //
}
t2()
// await 后面是 promise 对象时，将等待 promise 对象状态变更后，将resolve的值给前面的a变量
//promise对象要加上catch捕获异常，不然如果里面是reject就报错了(入过是resolve，后面不加catch也没问题)



async function t3() {
    let a = await new Promise((resolve) => {
        resolve()
    })
    console.log(a) //undefined
}
t3()
// promise 对象resolve返回为空


async function t4() {
    let a = await new Promise((resolve) => {
        resolve("hello")
    });
    console.log(a) //hello
}
t4()


async function t5() {
    let a = await new Promise((resolve) => {
        resolve("hello")
    }).then(() => { 
        return "lala"
    })
    console.log(a) //lala
}
t5()
// 返回then里面回调函数返回的值


async function t6() {
    console.log(fn());
    let a = await fn().then((res)=>{return res})
    console.log(a) //undefined
  }
  async function fn(){
      await new Promise((resolve)=>{
          resolve("lagou")
      })
  }
  t6()
  // async 修饰的函数也是返回一个promise对象，then里面接收到的值为函数返回的值
  
  
  async function t7() {
    let a = await fn().then((res) => { return res })
    console.log(a)
}
async function fn() {
    await new Promise((resolve) => {
        resolve("lagou")
    })
    return "lala"
}
t7()

• async 函数执行返后返回一个 promise 对象，这个函数返回值是这个 promise 状态值 resolve 的值
• await 后面如果不是一个promise对象，直接返回这个值
• await 后面如果是一个promise对象，将会把这个promise的状态resolve的值给返回出去

题目4

new Promise(function (resolve, reject) {
    console.log("AAAA");
    resolve();
})
    .then(function () {
        new Promise(function (resolve, reject) {
            console.log("BBBB");
            resolve();
        })
            .then(function () {
                console.log("CCCC");
            })
            .then(function () {
                new Promise(function (resolve, reject) {
                    console.log("DDDD");
                    resolve();
                })
                    .then(function () {
                        console.log("EEEE");
                    })
                    .then(function () {
                        console.log("FFFF");
                    });
                console.log("GGGG");
            });
        console.log("HHHH");
    })
    .then(function () {
        console.log("IIII");
    });

new Promise(function (resolve, reject) {
    console.log("JJJJ");
    resolve();
})
    .then(function () {
        console.log("KKKK");
    })
    .then(function () {
        console.log("LLLL");
    });

答案： A J B H K C I L D G E F

解析

• 执行new promise，打印A，将第一个 then里回调函数p1t1，放入微队列
• quene = [p1t1]
• 执行第二个new promise，打印J，将这个promise对象的then里的回调函数p2t1放入微队列
• quene = [p1t1,p2t1]
• 当前执行栈空了，将微队列里面需要执行的推入执行栈
• 执行p1t1，新建promise对象p3，打印B，将p3的then里的回调函数p3t1放入微队列；继续执行p1t1打印H。
• quene = [p2t1,p3t1]
• 执行完p1t1后返回一个promise，将then里的函数放入微队列p1t2
• quene = [p2t1,p3t1,p1t2]
• 执行p2t1，打印k,返回一个promise，将接下来的then里的回调p2t2放入微队列
• quene = [p3t1,p1t2,p2t2]
• 执行p3t1，打印C，返回一个promise，将接下来的then里的回调p3t2放入微队列
• quene = [p1t2,p2t2,p3t2]
• 执行p1t2，打印I
• quene = [p2t2,p3t2]
• 执行p2t2，打印L
• quene = [p3t2]
• 执行p3t2，新建一个promise对象p4，执行同步任务，打印DG,将接下来的第一个then里面的回调p4t1放入微任务队列
• quene = [p4t1]
• …
• 打印E，F