Bagaimana untuk menulis janji dua fasa yang lebih ringkas dalam JavaScript/TypeScript?

Question

Kes penggunaan saya di sini:

• Jika sumber itu tersedia serta-merta, pulangkan semula
• Tunjukkan penunjuk modal atau pemuatan jika sumber belum tersedia, kemudian tunggu ia siap
• Logik modal mesti dipisahkan daripada logik janji/permintaan

Adakah corak reka bentuk yang lebih baik?

let twoStagePromise = (state: boolean): Promise<{ ready: boolean, wait: Promise<any>; }> => {
    return new Promise((resolve, reject) => {
        try {
            if (state) {
                resolve({
                    ready: true,
                    wait: new Promise((resolve, reject) => {
                        resolve([1, 2, 3]);
                    })
                });
            } else {
                resolve({
                    ready: false,
                    wait: new Promise((resolve, reject) => {
                        setTimeout(() => { resolve([1, 2, 3]); }, 1000);
                    })
                });
            }
        } catch (e) {
            reject(e);
        }
    });
};

twoStagePromise(false).then((data) => {
    if (!data.ready) {
        console.log('loading...');
    }
    return data.wait;
}).then((result) => {
    console.log("recieved result", result);
}).catch((error) => {
    console.log("try-catch failed or inner promise failed")
});

Selepas membaca beberapa komen, saya memudahkan kod dengan ketara:

let twoStagePromise = (state: boolean): Promise<number[] | Promise<number[]>> => {
    return new Promise((resolve, reject) => {
        try {
            if (state) {
                resolve([1, 2, 3]);
            } else {
                resolve(new Promise((resolve) => setTimeout(() => { resolve([1,2,3])  }, 1000)))
            }
        } catch (e) {
            reject(e);
        }
    });
};

twoStagePromise(false).then((dataOrPromise) => {
    if (dataOrPromise instanceof Promise) {
        console.log('loading...');
    }
    return dataOrPromise // continue the promise chain by returning the promise or data
}).then((result) => {
    console.log("recieved result", result);
}).catch((error) => {
    console.log("try-catch failed or inner promise failed", error)
});

Answer 1

Anda boleh mencipta fungsi yang secara eksplisit mengembalikan nilai atau janjinya. Bagaimanapun anda boleh dengan mudah await 了。要检查结果是否同步，请使用 result instanceof Promise

type Awaitable = T | Promise
function maybeImmediate(
    call: () => Awaitable,
    tryImmediate: boolean,
): Awaitable {
    if (tryImmediate) {
        try {
            return call(); // you don't know if it's T or Promise actually
        } catch (err) {
            // choose the one you want
            if (Math.random() > 0.5) {
                throw err;
            } else {
                return Promise.reject(err)
            }
        }
    } else {
        // make sure it's a promise
        return Promise.resolve().then(() => call())
    }
};

let cache: Record = {};
function getCached(url: string): Awaitable {
    if (cache[url]) return cache[url];
    return new Promise(r => {
        setTimeout(() => r('result of ' + url), 1000)
    }).then(v => { cache[url] = v; return v })
}