Handwritten promise [04] - then method chain call to recognize promise object self return

Let's look at an example ：

let promise = new Promise((resolve, reject) => {
    
    resolve(1000);
})

let p1 = promise.then(value => {
    
    console.log(value);
    return p1;
})

p1.then(resolve => {
    
    console.log(resolve);
}, reject => {
    
    console.log(reject);
})

In a situation like this ,p1 Of then It calls itself again Promise object , It's a dead cycle , An error will be reported here .

[TypeError: Chaining cycle detected for promise #<Promise>]

therefore , We will continue to improve Promise Give Way LyPromise It can also report an error when a circular call occurs .

Promise2 Is returned Promise object ,x yes success / Failed callback After the return of Promise object , If the two values are the same, it means that you have returned your own .
therefore , Add a judgment ：

function resolvePromise(Promise2, x, resolve, reject) {
    
    if (Promise2 === x) {
    
        return reject(new TypeError("Promise  Referenced circularly ！！！"))
    }
    if (x instanceof LyPromise) {
     // promise object 
        x.then(resolve, reject)
    } else {
      //  Common value 
        resolve(x);
    }

}

It is worth noting that ,Promise2 Object is in new LyPromise After execution To get it , But we need to Promise2 stay new Of In the process Just pass it on to resolvePromise function . Obviously, the current code can not meet such requirements , Because you can't get it at this time Promise2.

There is an asynchronous problem here , So we need to use a timer , Give Way new LyPromise This After the process Let's do it again resolvePromise function , You can get Promise2.

Test code ：

let promise = new LyPromise((resolve, reject) => {
    
    resolve(1000);
})

let p1 = promise.then(value => {
    
    console.log(value);
    return p1;
})

p1.then(resolve => {
    
    console.log(resolve);
}, reject => {
    
    console.log(reject);
})

Running results ：

up to now , We have achieved then Method How to judge in chain call Promise Did you return to yourself .

Complete code ：

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

class LyPromise {
    
    constructor(executor) {
    
        executor(this.resolve, this.reject)
    }

    status = PENDING;

    value = undefined;
    reason = undefined;

    //  Successful callback 
    successCallback = [];
    //  Failed callback 
    failCallback = [];

    resolve = (value) => {
    
        if (this.status !== PENDING) return;
        this.status = FULFILLED;
        this.value = value;
        //  Determine whether a successful callback exists , If there is   Call the successful callback 
        // this.successCallback && this.successCallback(this.value);
        while (this.successCallback.length) {
    
            this.successCallback.shift()(this.value); // perform 
        }

    }

    reject = (reason) => {
    
        if (this.status !== PENDING) return;
        this.status = REJECTED;
        this.reason = reason;
        //  Determine whether the failed callback exists , If there is   Call the failed callback 
        // this.failCallback && this.failCallback(this.reason)
        while (this.failCallback.length) {
    
            this.failCallback.shift()(this.reason)
        }

    }

    then(successCallback, failCallback) {
    
        let Promise2 = new LyPromise((resolve, reject) => {
    
            if (this.status === FULFILLED) {
    
                setTimeout(() => {
    
                    let x = successCallback(this.value);
                    resolvePromise(Promise2, x, resolve, reject);
                }, 0)
            } else if (this.status === REJECTED) {
    
                setTimeout(() => {
    
                    let x = failCallback(this.reason);
                    resolvePromise(Promise2, x, resolve, reject)
                }, 0)
            } else {
    
                //  When the actuator operates asynchronously ,status still pending,
                //  So at this time, we don't know whether it is a success or a failure callback , So here we need to call back these two 
                //  Store it 
                this.successCallback.push(successCallback);
                this.failCallback.push(failCallback);
            }
        })

        return Promise2;

    }
}


function resolvePromise(promise2, x, resolve, reject) {
    
    if (promise2 === x) {
    
        return reject(new TypeError("Promise  Referenced circularly !!!"))
    }

    if (x instanceof LyPromise) {
     // promise object 
        x.then(resolve, reject)
    } else {
      //  Common value 
        resolve(x);
    }

}

module.exports = LyPromise;