promise面试题收集1

1.第一题

const promise = new Promise((resolve, reject) => {
     console.log(1)
     resolve()
     console.log(2)
})
promise.then(() => {
    console.log(3)
})
console.log(4)

答案：【1，2，4，3】

// 控制台：【1，2，4，3】
1. new Promise 里的参数函数，是同步被执行的，先输出 1，2
2. resolve 后还需要等待进入下一个事件循环。then 把参数函数推入微任务队列，并不直接执行
3. 输出 4（同步代码），接着事件循环进入下一轮，输出 3

2.第二题

        var promise = new Promise(function (resolve, reject) {
            setTimeout(function () {
                resolve(1);
            }, 3000)
        })
        promise.then((a) => {
            console.log(a)
            return Promise.resolve(2);
        }).then((n) => {
            console.log("b")
            console.log(n)
        });

答案：【1，b，2】

Promise.resolve 就是一个 Promise 对象就相当于返回了一个新的 Promise 对象。然后在下一个事件循环里才会去执行 then

3.第三题

        var promise = new Promise(function (resolve, reject) {
            setTimeout(function () {
                resolve(1);
            }, 3000)
        })
        promise.then(() => {
            return 2
        }).then((n) => {
            console.log(n)
        });

答案：【2】

和上一题不一样的是，它不用等下一个事件循环

4.第四题

        var promise = new Promise(function (resolve, reject) {
             setTimeout(function () {
                 resolve(1);
             }, 3000)
         })
         promise.then(2).then((n) => {
             console.log(n)
         });

答案：【1】

then 和 catch 期望接收函数做参数，如果非函数就会发生 Promise 穿透现象，打印的是上一个 Promise 的返回

5.第五题

        let a;
        const b = new Promise((resolve, reject) => {
            console.log('promise1');
            resolve();
        }).then(() => {
            console.log('promise2');
        }).then(() => {
            console.log('promise3');
        }).then(() => {
            console.log('promise4');
        });

        a = new Promise(async (resolve, reject) => {
            console.log(a);
            await b;
            console.log(a);
            console.log('after1');
            // resolve()
            await a
            resolve(true);
            console.log('after2');
        });

        console.log('end');

答案：【promise1，undefined，end ，promise2，promise3，promise4，(pending)，after1，undefined】

6.第六题

        const promise = new Promise((resolve, reject) => {
            resolve('success1');
            reject('error');
            resolve('success2');
        });

        promise
        .then((res) => {
            console.log('then: ', res);
        })
        .catch((err) => {
            console.log('catch: ', err);
        });

答案：【then:success1】

promise状态只能被改变一次

7.第七题

        Promise.resolve()
            .then(() => {
                return new Error('error!!!')
            })
            .then((res) => {
                console.log('then: ', res)
            })
            .catch((err) => {
                console.log('catch: ', err)
            })

答案：【then:Error: error!!!】

没有抛出错误和异常，只是 return 了一个对象，哪怕他是 Error 对象，那自然也是正常走 then 的链式调用下去了，不会触发 catch。

8.第八题

        const promise = new Promise((resolve, reject) => {
            console.log(1);
            resolve();
            console.log(2);
            reject('error');
        })
        promise.then(() => {
            console.log(3);
        }).catch(e => console.log(e))
        console.log(4);

答案：【1，2，4，3】

promise只能被修改一次，所以catch不再执行

9.第九题

        const promise = new Promise((resolve, reject) => {
             setTimeout(() => {
                 console.log('once')
                 resolve('success')
             }, 1000)
         })
         promise.then((res) => {
             console.log(res)
         })
         promise.then((res) => {
             console.log(res)
         })

答案：【once，success，success】

promise的构造函数只会执行一次，而then方法可以多次调用，但是第二次返回结果，不会有异步等待的时间

10.第十题

        const p1 = () => (new Promise((resolve, reject) => {
            console.log(1);
            let p2 = new Promise((resolve, reject) => {
                console.log(2);
                const timeOut1 = setTimeout(() => {
                    console.log(3);
                    resolve(4);
                }, 0)
                resolve(5);
            });
            resolve(6);
            p2.then((arg) => {
                console.log(arg);
            });

        }));
        const timeOut2 = setTimeout(() => {
            console.log(8);
            const p3 = new Promise(reject => {
                reject(9);
            }).then(res => {
                console.log(res)
            })
        }, 0)
        p1().then((arg) => {
            console.log(arg);
        });
        console.log(10);

答案：【1,2,10, 5,6, 8,9, 3】

1.执行同步代码，打印1，2，10
2.执行第一层微任务将5，6打印
3.因为两个定时器的时间都是一样的，所以先执行全局的定时器，进入定时器后，打印8，9
4.最后执行timeOut1定时器任务，打印3
5.因为promise只能被修改一次，所以4打印不出来