Promise原理再回顾和面试可用的源码书写

最新推荐文章于 2024-05-04 18:03:08 发布
最新推荐文章于 2024-05-04 18:03:08 发布
阅读量952 收藏 2
点赞数
分类专栏： 原生js 文章标签： javascript ecmascript es6 promise 异步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40566547/article/details/121435289
版权

       继上一次重写Promise之后，已有两年了。由于个人原因，毕业之后从前端转向了后端，但按捺不住前端之心，于是最近几天重新开始学了一下，目前学到了异步处理这一块，重写Promise，算是回顾自己，加深对Promise的理解。

什么是Promise？

       我们都知道Promise是ES6推出的一个官方标准，其实在官方推出之前，社区就已经有Promise，并且形成了一些规范，这些规范称为Promise A规范（后拓展到Promise A+规范）。译文如下：

[译]Promise/A+ 规范

        另外我们也应该已经知道了，宏任务和微任务的一些相关知识。我大胆的总结一下：

宏任务（或称宏队列）：在ES6推出之前所有的异步操作都是宏任务，包括网络、事件监听、计时等

微任务（或称微队列）：在ES6推出之后的异步操作都属于微任务，包括Promise、MutationObserver（H5的一系列Observer）

        这里不得不重新提一下JS引擎执行的机制，由于JS引擎单线程的原因，前端省去了多任务操作时共享数据、死锁等一系列问题，但也引入了一些其他麻烦，诸如大数据量耗时操作的同步处理问题，在以前我们都是丢到setTimeout里，让计时线程去做这个事，引起这一操作的原理可以大致总结如下：

JS执行时会向执行栈推入一些数据，这些数据里面存储了每一个函数执行时的上下文（诸如AO、GO）

JS会首先将执行栈里面的执行完，执行一个移除一个（栈是先进后出，所有一个函数藏得越深被执行时最先退出执行栈）

执行栈清空之后，浏览器会在内部开一个线程定期去看任务队列里面有没有任务，如果有就会将任务队列里的第一个拿出来到执行栈去执行，直到把任务队列也清空

任务队列有两个，宏任务队列和微任务队列，微任务队列里的任务优先级比宏任务队列里的任务优先级高，所以都是将微任务队列里的任务清空之后再去清空宏任务队列里的任务

 开始编写Promise

        编码之前，读者需将Promise的执行例子多写几个，了解一下Promise如何执行的，可更有效

1. 状态改变

        Promise A+规范，规定Promise有3个状态，分别是pending、fulfilled、rejected，这三个状态只能由pending=>fulfilled或pending=>rejected，状态转换不可逆，且只能执行一次，多次执行只会取第一次状态改变的那个结果。

const PENDING = 'pending';
const REJECTED = 'rejected';
const RESOLVED = 'resolved';


class MyPromise {
    _changeState = (newState, data) => {
        if (this._state !== PENDING) return;
        this._state = newState;
        this.value = data;
    }
    _reject = reason => {
        this._changeState(REJECTED, reason);
    }
    _resolve = value => {
        this._changeState(RESOLVED, value);
    }
    constructor(excutor) {
        this._state = PENDING;
        this._value = undefined;
        try {
            excutor(this._resolve, this._reject);
        }
        catch (err) {
            this._reject(err);
        }
    }
}

2. 模拟微任务队列

        我们都知道微任务是要先于宏任务执行的，所以我们这里不能简单地使用setTimeout进行模拟，这里有两种方法来模拟，一个是Node环境一个是浏览器环境下：

        Node环境我们一般用：process.nextTick，在下一个tick回调函数会被扔到微队列

        浏览器环境我们使用：MutationObserver，监听元素内部发生变化是，会将回调函数扔到微队列

        其他情况没办法只能使用setTimeout

function runMicroTask(cb) {
    if (process && process.nextTick) {
        process.nextTick(cb);
    }
    else if (MutationObserver) {
        // MutationObserver在监听元素内部变化时，会将回调函数放到微队列，很适合我们模拟微任务队列
        const p = document.createElement('p');
        const observer = new MutationObserver(cb);
        observer.observe(p,
            {
                childNodes: true,
            });
        p.innerHTML = "1";
    }
    else {
        setTimeout(cb, 0);
    }
}

3. 重头戏开始，编写then

       Promise的then函数都有一个特点，即不论你怎么写代码，它都返回一个Promise，啥也不说，咱们上来就是一个返回Promise：

class MyPromise {

    constructor(executor) {
        this._state = PENDING;
        this._value = undefined;
        + this._handlers = [];
        try {
            excutor(this._resolve, this._reject)
        } catch (err) {
            this._reject(err);
        };
    }

    _pushHandler = (executor, state, resolve, reject) => {
        this.handlers.push({ executor, state, resolve, reject });
    }

    then = (onFulfilled, onRejected) => {
        return new MyPromise((resolve, reject) => {
            this._pushHandler(onFulfilled, RESOLVED, resolve, reject);
            this._pushHandler(onRejected, REJECTED, resolve, reject);
            this._runHandlers();
        });
    }
}

做一下解释：

由于Promise的then方法里的函数并不是立即执行，而是需要上一个Promise决议之后才会执行，所以这里需要保存当前执行的方法还有对应决议时调用的resolve或reject方法，来改变当前Promise的状态，而调用resolve或reject方法与onFulfilled或onRejected方法有关，所以也需要保存当前方法执行时所处的状态

        所以then函数并不会立即执行回调函数，想要执行回调函数还得等到上一个Promise状态改变，所以我们需要在状态改变的时候执行将执行队列里的每一个函数分状态情况执行

3. 执行执行队列

执行执行队列时，我们需要搞清楚在什么时候执行，即状态变更的时候进行执行，但状态变更有两种情况。

        立即变更：立即变更时，我们需要马上调用then函数，将then里的回调函数扔到微任务，去执行微任务

new Promise((resolve, reject) => {
    resolve(1)
}).then(data => {
    console.log(data);
})

        延迟变更：延迟变更时，由于状态没有发生改变，调用then方法时，不会立即将回调函数扔到微任务队列去，例如

new Promise((resolve, reject) => {
    setTimout(() => {
        resolve(123);
    }, 500);
}).then(data => {
    console.log(data); // 500ms之后才会输出
})

        所以执行执行队列时，有两个地方执行他，分别是then、changeState

        这里还需要各位根据Promise的规则去尝试一下，各种返回情况下是怎么个结果

代码如下：

function isThenable(obj) {
    return !!(obj && typeof obj === 'object' && typeof obj.then === 'function' && obj.then.length === 2);
}

class MyPromise {

    _changeState = (newState, value) => {
        if (this._state !== PENDING) return;
        this._state = newState;
        this._value = value;
        + this._runHandlers();
    }   

    _runHandlers = () => {
        if (this._state === PENDING) return;
        while (this._handlers[0]) {
            this._runHandler(this._handlers[0]);
            this._handlers.shift();
        }
    }

    _runHandler = ({ executor, reject, resolve, state }) => {
        runMicroTask(() => {
            if (state !== this._state) {
                return;
            }

            // 传递的执行函数不是一个函数那么返回的Promise应该具有和当前Promise一样的状态和数据
            if (typeof executor !== 'function') {
                this._state === REJECTED ?
                    reject(this._value) :
                    resolve(this._value);
                return;
            }
            try {
                const result = executor(this._value);

                // 是否含有then方法
                if (isThenable(result)) {
                    result.then(resolve, reject);
                }
                else {
                    resolve(result);
                }
            } catch (err) {
                reject(err);
            }
        });
    }
}

重难点解析：

        关于thenable：Promise A+规范并没有规定说Promise必须是某某对象，而是指具有thenable方法的鸭子类型的对象，所以在上古时期，就算每个厂家的Promise不同，但却能够很好的相互结合工作，是因为他们都基于Promise A+规范实现的。所以一个对象只要是thenable，就可以将结果进行执行输出。

        Promise执行时，如果传入的参数不是一个函数，那么就相当于跳过，所以他返回的这个Promise就应具有上一个Promise的状态和值等信息

好了，Promise A+ 规范的Promise最基本的已经完成。

注意：实现了Promise A+规范的Promise可以和Promise混用，而且支持async await等新语法

这一部分代码如下：


const PENDING = 'pending';
const REJECTED = 'rejected';
const RESOLVED = 'resolved';

/**
 * 把传递的函数放到微队列里（模拟）
 * @param {Function}} cb 回调函数
 */
function runMicroTask(cb) {
    if (process && process.nextTick) {
        process.nextTick(cb);
    }
    else if (MutationObserver) {
        // MutationObserver在监听元素内部变化时，会将回调函数放到微队列
        const p = document.createElement('p');
        const observer = new MutationObserver(cb);
        observer.observe(p,
            {
                childNodes: true,
            });
        p.innerHTML = "1";
    }
    else {
        setTimeout(cb, 0);
    }
}

function isThenable(obj) {
    return !!(obj && typeof obj === 'object' && typeof obj.then === 'function' && obj.then.length === 2);
}

class MyPromise {

    then = (onFulfilled, onRejected) => {
        return new MyPromise((resolve, reject) => {
            this._pushHandler(onFulfilled, RESOLVED, resolve, reject);
            this._pushHandler(onRejected, REJECTED, resolve, reject);
            this._runHandlers();
        });
    }

    _pushHandler = (executor, state, resolve, reject) => {
        this._handlers.push({ executor, state, resolve, reject });
    }

    _runHandlers = () => {
        if (this._state === PENDING) return;
        while (this._handlers[0]) {
            this._runHandler(this._handlers[0]);
            this._handlers.shift();
        }
    }

    _runHandler = ({ executor, reject, resolve, state }) => {
        runMicroTask(() => {
            if (state !== this._state) {
                return;
            }

            // 传递的执行函数不是一个函数那么返回的Promise应该具有和当前Promise一样的状态和数据
            if (typeof executor !== 'function') {
                this._state === REJECTED ?
                    reject(this._value) :
                    resolve(this._value);
                return;
            }
            try {
                const result = executor(this._value);

                // 是否含有then方法
                if (isThenable(result)) {
                    result.then(resolve, reject);
                }
                else {
                    resolve(result);
                }
            } catch (err) {
                reject(err);
            }
        });
    }

    _changeState = (newState, value) => {
        if (this._state !== PENDING) return;
        this._state = newState;
        this._value = value;
        this._runHandlers(); // 执行队列
    }

    _resolve = value => {
        this._changeState(RESOLVED, value);
    }

    _reject = reason => {
        this._changeState(REJECTED, reason);
    }

    constructor(excutor) {
        this._state = PENDING;
        this._value = undefined;
        this._handlers = [];
        try {
            excutor(this._resolve, this._reject)
        } catch (err) {
            this._reject(err);
        };
    }
}

接下来，稍微测试一下：

/*****************测试1 start********************/
console.log('start');

setTimeout(() => {
    console.log('setTimeout1');
}, 0);

const pro = new MyPromise((resolve, reject) => {
    console.log('promise1');
    setTimeout(() => {
        console.log('setTimeout2');
        resolve(1);
    }, 100);
});

pro.then(data => {
    console.log('promise2');
    return new MyPromise((resolve, reject) => {
        resolve(data);
    })
}).then(data => {
    console.log(data);
});

console.log('end');
/*****************测试1 end********************/
/*****************语法测试 start********************/
(async () => {
    const n = await new MyPromise((resolve, reject) => {
        resolve(1);
    });

    console.log(n);
})();
/*****************语法测试 end********************/

测试结果如下：

 4. 其他实例方法catch、finally

then完成了，catch和finally就异常简单，只不过需要注意finally。执行finally时，是没有参数的，且如果执行过程没报错的话，返回的Promise是没有value的，如果执行报错的话，返回的Promise中value就是报错的内容。

class MyPromise {

    catch = onRejected => {
        return this.then(null, onRejected);
    }

    finally = onFinally => {
        let fn = data => onFinally(data);
        // 这里给包一层，避免将onFinally传递下去时含有参数。在reject里手动抛个错，让then捕获
        return this.then(
            data => {
                onFinally();
                return data;
            },
            reason => {
                onFinally();
                throw reason;
            });

    }

}

 接下来就是一些静态方法的编码了，这一部分，需要读者自己去了解Promise的静态方法执行规则，我就不再这里讲解用法了。

class MyPromise {

    static race = iterators => {
        return new MyPromise((resolve, reject) => {
            for (const iterator of iterators) {
                // 当前Promise的状态只能变一次，所以这里我简写一下
                Promise.resolve(iterator).then(resolve, reject);
            }
        });
    }

    static allSettled = iterators => {
        const ps = [];
        for (const iterator of iterators) {
            // 这里有个技巧，将每一个promise的then先写好，避免后续报错影响
            ps.push(MyPromise.resolve(iterator).then(value => ({ status: RESOLVED, value }), reason => ({ status: REJECTED, reason })));
        }

        return MyPromise.all(ps);
    }

    static all = (iterators) => {
        return new MyPromise((resolve, reject) => {
            try {
                let count = 0;
                let reolvedCount = 0;
                const results = [];
                for (const iterator of iterators) {
                    let i = count; // 确保当前这一次的i和异步的i是一样的
                    MyPromise.resolve(iterator).then(data => {
                        reolvedCount++;
                        results[i] = data;
                        // 当前是最后一个promise，则全部完成
                        if (reolvedCount == count) {
                            resolve(results);
                        }
                    }, reject);
                    count++;
                }
                
                // MDN上规定如果all方法的参数为空数组就直接返回空数组
                if (!iterators.length) {
                    resolve(results);
                }
            } catch (err) {
                reject(err);
            }
        })
    }

    static resolve(obj) {
        if (obj instanceof MyPromise) {
            return obj;
        }

        return new MyPromise((resolve, reject) => {
            if (isThenable(obj)) {
                obj.then(resolve, reject);
            }
            else {
                resolve(obj);
            }
        });
    }

    static reject(reason) {
        return new MyPromise((resolve, reject) => {
            reject(reason);
        });
    }
}

源代码如下：


const PENDING = 'pending';
const REJECTED = 'rejected';
const RESOLVED = 'resolved';

function runMicroTask(cb) {
    if (process && process.nextTick) {
        process.nextTick(cb);
    }
    else if (MutationObserver) {
        // MutationObserver在监听元素内部变化时，会将回调函数放到微队列
        const p = document.createElement('p');
        const observer = new MutationObserver(cb);
        observer.observe(p,
            {
                childNodes: true,
            });
        p.innerHTML = "1";
    }
    else {
        setTimeout(cb, 0);
    }
}

function isThenable(obj) {
    return !!(obj && typeof obj === 'object' && typeof obj.then === 'function' && obj.then.length === 2);
}

class MyPromise {

    static race = iterators => {
        return new MyPromise((resolve, reject) => {
            for (const iterator of iterators) {
                Promise.resolve(iterator).then(resolve, reject);
            }
        });
    }

    static allSettled = iterators => {
        const ps = [];
        for (const iterator of iterators) {
            ps.push(MyPromise.resolve(iterator).then(value => ({ status: RESOLVED, value }), reason => ({ status: REJECTED, reason })));
        }

        return MyPromise.all(ps);
    }

    static all = (iterators) => {
        return new MyPromise((resolve, reject) => {
            try {
                let count = 0;
                let reolvedCount = 0;
                const results = [];
                for (const iterator of iterators) {
                    let i = count; // 确保当前这一次的i和异步的i是一样的
                    MyPromise.resolve(iterator).then(data => {
                        reolvedCount++;
                        results[i] = data;
                        // 当前是最后一个promise，则全部完成
                        if (reolvedCount == count) {
                            resolve(results);
                        }
                    }, reject);
                    count++;
                }
                if (!iterators.length) {
                    resolve(results);
                }
            } catch (err) {
                reject(err);
            }
        })
    }

    static resolve(obj) {
        if (obj instanceof MyPromise) {
            return obj;
        }

        return new MyPromise((resolve, reject) => {
            if (isThenable(obj)) {
                obj.then(resolve, reject);
            }
            else {
                resolve(obj);
            }
        });
    }

    static reject(reason) {
        return new MyPromise((resolve, reject) => {
            reject(reason);
        });
    }

    then = (onFulfilled, onRejected) => {
        return new MyPromise((resolve, reject) => {
            this._pushHandler(onFulfilled, RESOLVED, resolve, reject);
            this._pushHandler(onRejected, REJECTED, resolve, reject);
            this._runHandlers(); // 执行队列
        });
    }

    catch = onRejected => {
        return this.then(null, onRejected);
    }

    finally = (onFinally) => {
        let fn = data => onFinally(data);
        return this.then(
            data => {
                onFinally();
                return data;
            },
            reason => {
                onFinally();
                throw reason;
            });

    }

    _pushHandler = (executor, state, resolve, reject) => {
        this._handlers.push({ executor, state, resolve, reject });
    }

    _runHandlers = () => {
        if (this._state === PENDING) return;
        while (this._handlers[0]) {
            this._runHandler(this._handlers[0]);
            this._handlers.shift();
        }
    }

    _runHandler = ({ executor, reject, resolve, state }) => {
        runMicroTask(() => {
            if (state !== this._state) {
                return;
            }

            // 传递的执行函数不是一个函数那么返回的Promise应该具有和当前Promise一样的状态和数据
            if (typeof executor !== 'function') {
                this._state === REJECTED ?
                    reject(this._value) :
                    resolve(this._value);
                return;
            }
            try {
                const result = executor(this._value);

                // 是否含有then方法
                if (isThenable(result)) {
                    result.then(resolve, reject);
                }
                else {
                    resolve(result);
                }
            } catch (err) {
                reject(err);
            }
        });
    }

    _changeState = (newState, value) => {
        if (this._state !== PENDING) return;
        this._state = newState;
        this._value = value;
        this._runHandlers(); // 执行队列
    }

    _resolve = value => {
        this._changeState(RESOLVED, value);
    }

    _reject = reason => {
        this._changeState(REJECTED, reason);
    }

    constructor(excutor) {
        this._state = PENDING;
        this._value = undefined;
        this._handlers = [];
        try {
            excutor(this._resolve, this._reject)
        } catch (err) {
            this._reject(err);
        };
    }
}

ainuo5213
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Promise的理解（面试题）
m0_49456900的博客
03-22 5450
Promise的基本用法、promise三种状态？总结Promise.resolve()方法参数的几种情况、Promise.all()和promise.race()、promise.any()的区别？Then方法中return的作用？
Promise超全面试整理
zzzld001的博客
07-23 339
Promise什么是PromisePromise特点Promise缺点Promise 链创建Promise对象Promise方法Promise.all和Promise.race的区别的使用场景代码实现Promise实现 Promise.all 什么是Promise Promise 对象是异步编程的一种解决方案，最早由社区提出。它是一个构造函数，接收一个函数作为参数，返回一个 Promise 实例。简单说就是一个容器，里面保存着某个未来才会结束的事件 (通常是一个异步操作)的结果。 Promise特点 对
Promise面试题合集(问题+答案)
DeepLearning_的博客
01-12 3276
好的，让我们来总结一下.then()和.race()吧，😄的作用是接收一组异步任务，然后并行执行异步任务，并且在所有异步操作执行完后才执行回调。.race()的作用也是接收一组异步任务，然后并行执行异步任务，只保留取第一个执行完成的异步操作的结果，其他的方法仍在执行，不过执行结果会被抛弃。结果中数组的顺序和接收到的数组顺序一致。all和race传入的数组中如果有会抛出异常的异步任务，那么只有最先抛出的错误会被捕获，并且是被then的第二个参数或者后面的catch捕获；
2024年js常见面试题——详解Promise使用与原理及实现过程（附源码），我是如何收割多家大厂offer的
最新发布
2401_84435152的博客
05-04 932
好了，这就是整理的前端从入门到放弃的学习笔记，还有很多没有整理到，我也算是边学边去整理，后续还会慢慢完善，这些相信够你学一阵子了。做程序员，做前端工程师，真的是一个学习就会有回报的职业，不看出身高低，不看学历强弱，只要你的技术达到应有的水准，就能够得到对应的回报。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】学习从来没有一蹴而就，都是持之以恒的，正所谓活到老学到老，真正懂得学习的人，才不会被这个时代的洪流所淘汰。res => {
【异步系列三】10道 Promise 面试题彻底理解 Promise 异步执行顺序
二三的博客
09-23 6984
上一篇文章详细说明了关于 Promise 的概念以及执行顺序，Promise 作为 JavaScript 中的关键特性，无论是在日常工作中还是面试中，我们都必须掌握它。前段时间在网上看到了一些关于 Promise 的面试题，质量很好，在这里整理到下面，并加上我一些自己的见解，欢迎斧正！
Promise的常见面试题
小草莓的博客
07-04 1460
一、对Promise的理解以及Promise的基本用法 二、Promise的其他常见方法 三、Promise的常见面试题 ① 多个.catch ② 多个.catch（不懂） ③ 链接.then和.catch（不懂） ④ 链接.catch（不懂） ⑤ 多个.catch（不懂） ⑥.then之间的流程 ⑦.then之间的流程 ⑧.then之间的流程 ⑨.then和.catch之间的流程（不懂） ⑩ 基础输出题 11、用Promise实现红绿灯不断交替亮
第5章 前端面试技能拼图3 ：知识深度 - 原理和源码
03-13
本章"第5章 前端面试技能拼图3：知识深度 - 原理和源码"将聚焦于这些关键点，帮助你构建一个完整的知识体系，以应对面试中的高难度问题。 首先，对于前端面试，深入理解JavaScript的基础至关重要。这包括但不限于...
前端Promise的理解的面试题
04-25
有关前端中的promise的理解和相关面试题，推荐要实习、就业的人在面试之前看看，提高自己的面试通过率，当然高手也可以看看来查缺补漏，有否新的感悟。 promise（承诺）是异步编程的一种解决方案； Promise 它是一...
前端面试大厂手写源码系列（上）
01-08
这个"前端面试大厂手写源码系列（上）"将探讨CSS和JavaScript部分的关键手写原理题目，特别是JavaScript中的原生Ajax实现，以及防抖和节流函数。 首先，我们来看原生Ajax的实现。Ajax全称为"Asynchronous ...
Promise原理介绍和实现.docx
05-06
总结起来，Promise是JavaScript异步编程的核心，通过理解和掌握Promise的工作原理及其实现，开发者能够更好地组织异步代码，提高代码的可读性和可维护性。在实际开发中，Promise与async/await结合使用，可以进一步...
Promise笔记
dihuaooo的博客
04-04 751
Promise笔记
promise 以及经典面试题
qq_43944285的博客
05-10 4691
在这里插入代码片
Promise
weixin_44932552的博客
07-24 385
一、定义： 所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。 Promise对象有以下两个特点。 （1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态. 2）一旦状态改变，就不会再变，任何时候都可以得到这
前端 面试----手写promise（promise自定义封装）
WXY博客
06-09 909
---------简单来说，函数是为了解决异步回调时的一些问题，更准确来说是为了解决我们在开发中，经常会面临的“回调地狱”所给开发者带来的困扰。promise可以被理解成一个方案，来有助于我们快速规避这些麻烦，从而提高我们的开发效率。----------我们知道一个Promise函数的状态必然处于以下几种状态中的一个：待定（pending）已兑现（fulfilled）已拒绝（rejected）
关于 ES6 中 Promise 的面试题
weixin_34268579的博客
10-29 569
说明 最近在复习 Promise 的知识，所以就做了一些题，这里挑出几道题，大家一起看看吧。 题目一 const promise = new Promise((resolve, reject) => { console.log(1); resolve(); console.log(2); }) promise.then(() => { console....
常见 Promise 面试问题
weixin_38300263的博客
11-23 3486
前端面试过程中，基本都会问到 Promise，如果你足够幸运，面试官问的比较浅，仅仅问 Promise 的使用方式，那么恭喜你。事实上，大多数人并没有那么幸运。所以，我们要准备好九浅一深的知识。 常见的promise面试问题 我们看一些 Promise 的常见面试问法，由浅至深。 了解 Promise 吗？ Promise 解决的痛点是什么？ Promise 解决的痛点还有其他方法可以解决吗？如果有，请列举。 Promise 如何使用？ Promise 常用的方法有哪些？它们的作用是什么..
Promise面试题汇总
热门推荐
公众号：前端充电宝
08-24 4万+
Promise回顾 Promise基础 Promise的catch、then、finally Promise的all和race Async、await 其他题目
promise原理 面试
05-12
1. Promise 构造函数接收一个函数作为参数，该函数包含两个参数：resolve 和 reject，分别表示 Promise 成功和失败时的回调函数。 2. Promise 有三种状态：Pending、Resolved 和 Rejected。 3. Promise 执行过程中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值