手写promise

 //异步实现的函数
        function runAsyncTask(callback) {
            if (typeof queueMicrotask === 'function') {
                queueMicrotask(callback)
            } else if (typeof MutationObserver === 'function') {
                const mutationObserver = new MutationObserver(callback)
                const oDiv = document.createElement('div')
                mutationOBserver.observe(oDiv, { childList: true })
                oDiv.innerText = 'logggle'
            } else {
                setTimeout(callback, 0)
            }
        }
        //将相同代码封装成函数
        function resolvePromise(p2, x, resolve, reject) {
            if (x === p2) {
                throw new TypeError('Chaining cycle detected for promise #<Promise>')
            }
            if (x instanceof Promise) {
                x.then(
                    (data) => {
                        resolve(data)
                    },
                    (err) => {
                        reject(err)
                    }
                )
            } else {
                resolve(x)
            }

        }
        //定义Promise三个状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejectted'
        class Promise {
            status = PENDING
            result = undefined
            #handles = []
            constructor(executor) {
                const resolve = (result) => {
                    if (this.status === PENDING) {
                        this.status = FULFILLED
                        this.result = result
                        this.#handles.forEach(({ onFulfilled }) => {
                            onFulfilled()
                        })
                    }
                }
                const reject = (result) => {
                    if (this.status === PENDING) {
                        this.sta