javascript Promises / A +链循环typeError表示无限循环使堆栈溢出，还是意味着永远停止的“待定”承诺？

问题描述

这是我自定义的promise实现，请忍受我的粗略编码。问题是有关以下检查的问题，以确保承诺没有循环引用。 Promises / A +表示会导致无限循环，但是当我运行测试时，它将立即停止。

if (bridgepromise === x) {
        return reject(new TypeError('Circular reference/Chaining cycle detected for promise #<Promise>'));
    }

所以我的考试是

let p = new customizedPromise((resolve,reject) => {
    resolve(1)
})

let testPromise = p.then(value => { return testPromise })

testPromise.then(data => console.log(data))

让我思考通过说无限循环来实现promise / A +是什么意思，这是否会导致resolvePromise函数反复运行？还是意味着它永远不会解决或拒绝？ 还是我兑现的承诺仍然存在错误？还是我的考试还不够？非常困惑。

当我在resolvePromise函数中使用console.log时，它那时没有到达回调，也没有达到下面的resolvePromise（bridgePromise，y，resolve，拒绝）。

  const PENDING = "pending";
const FULFILLED = "fulfilled";
const REJECTED = "rejected";

function customizedPromise(cb) {
    let self = this
    self.value = null;
    self.error = null;
    self.status = PENDING;
    self.onFulfilledCallBack = [];
    self.onRejectedCallBack = [];

    function resolve(value) {
        // be careful about setTimeout's this
        
            setTimeout(() => {
                if (self.status === PENDING){
                //actually here setting status is for later use
                self.status = FULFILLED;
                self.value = value;
                self.onFulfilledCallBack.forEach(cb => cb(value))}
            })
    }

    function reject(error) {
        
            setTimeout(() => {
                //actually here setting status is for later use
                if (self.status === PENDING){
                self.status = REJECTED;
                self.error = error;
                self.onRejectedCallBack.forEach(cb => cb(error))}
            })
    }

    cb(resolve,reject)
}

// be careful about arrow function's this if you define then function as an arrow function
// it will point to the window
customizedPromise.prototype.then = function (onFulfilled,onRejected) {

    let self = this;
    let bridgePromise;

    onFulfilled = typeof onFulfilled === "function" ? onFulfilled : value => value;
    onRejected = typeof onRejected === "function" ? onRejected : error => { throw error };

    if (self.status === FULFILLED) {
        return bridgePromise = new customizedPromise((resolve,reject) => {
            setTimeout(() => {
                try {
                    let x = onFulfilled(self.value);
                    resolvePromise(bridgePromise,x,resolve,reject);
                } catch (e) {
                    reject(e);
                }
            });
        })
    }
    if (self.status === REJECTED) {
        return bridgePromise = new customizedPromise((resolve,reject) => {
            setTimeout(() => {
                try {
                    let x = onRejected(self.error);
                    resolvePromise(bridgePromise,reject);
                } catch (e) {
                    reject(e);
                }
            });
        });
    }

    if (self.status === PENDING) {
        return bridgePromise = new customizedPromise((resolve,reject) => {
            self.onFulfilledCallBack.push((value) => {
                try {
              
                    let x = onFulfilled(value);
                    resolvePromise(bridgePromise,reject);
                } catch (e) {
                    reject(e);
                }
            });
            self.onRejectedCallBack.push((error) => {
                try {
                    let x = onRejected(error);
                    resolvePromise(bridgePromise,reject);
                } catch (e) {
                    reject(e);
                }
            });
        });
    }
}


function resolvePromise(bridgePromise,reject) {

    let called = false;

/* this if condition is not here when I run test */
    **if (bridgePromise === x) {
        return reject(new TypeError('Circular reference/Chaining cycle detected for promise #<Promise>'));
    }**

    if (x != null && ((typeof x === 'object') || (typeof x === 'function'))) {
        try {
            let then = x.then;
            if (typeof then === 'function') {
                then.call(x,y => {
                    console.log("it is not reaching here,hence no reference cycle")
                    if (called) return;
                    called = true;
                    resolvePromise(bridgePromise,y,reject);
                },error => {
                    if (called) return;
                    called = true;
                    reject(error);
                })
            } else {
                resolve(x);
            }
        } catch (e) {
            if (called) return;
            called = true;
            reject(e);
        }
    }
    else {
        resolve(x);
    }
}

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）