प्रकार व्याख्या reflectPromise विधि

Question

प्रकार व्याख्या reflectPromise विधि

वोट

0

मैं का एक संस्करण annoate टाइप करने के लिए कोशिश कर रहा था reflectयहां से वादा विधि - https://stackoverflow.com/a/31424853/1828637

function reflectPromise(p){
    return p.then(data => ({
                data,
                resolved: true
             }))
            .catch(error => ({
                error,
                rejected: true
             }));
}

क्या यह करता है एक वादा ले जाता है, और एक अन्य वादा जब यह संकल्प लिया या अस्वीकार कर दिया है देता है।

चीजें मैं स्यूडोकोड से कोई लेना देना कोशिश कर रहा हूँ:

घोषणा करते हैं कि dataहैtypeof ResolveValue(p)
घोषणा करते हैं कि errorहैtypeof RejectValue(p)
घोषणा करते हैं कि दूसरों का परीक्षण कर सकते const didReject = !!(await (reflectedPromise(somePromise)).rejected(क्या यह जो रिटर्न का समाधान वादों के लिए क्या करेंगे, { data: xxx, resolved:true }) बारी है undefinedकरने के लिए true। वर्तमान में जब मैं करता हूँ !!blah.rejectedटाइपप्रति मेरे लिए कहते हैंProperty 'rejected' does not exist on type

अभी तक मेरे पास इतना ही है:

function reflectPromise(p: Promise<any>): Promise<
        { data: any, resolved: boolean, rejected: void  } |
        { error: any, resolved: void, rejected: boolean }
    > {
    return p.then(data: any) => ({
                data,
                resolved: true
             }))
            .catch((error: any) => ({
                error,
                rejected: true
             }));
}

typescript

19/09/2018 को 21:29
का स्रोत उपयोगकर्ता Noitidart

अन्य भाषाओं में...

1 जवाब

Titian Cernicova-Dragomir · Accepted Answer · 2018-09-19 22:41

आप अनुमान लगाया परिणाम के प्रकार के लिए एक सामान्य प्रकार का उपयोग करने की जरूरत है। त्रुटि का प्रकार माना जाता है anyटाइपप्रति में और वहां कोई नहीं प्रकार सुरक्षा है। इसके अलावा, मैं टाइप करेंगे rejectedऔर resolvedके रूप में undefinedनहीं void(उनके मूल्य तो यह और अधिक acurate है रनटाइम पर सब के बाद अपरिभाषित किया जाएगा) और मैं उन्हें वैकल्पिक बनाना होगा, जब वे मौजूद नहीं हैं।

इसके अलावा जब resolveऔर rejectकर रहे हैं true, मैं बूलियन शाब्दिक प्रकार के रूप में उन्हें टाइप करेंगे trueआदेश टाइप गार्ड बेहतर काम करने के लिए अनुमति देने के लिए।

यह एक साथ रखें, इस संकलित (सख्त अशक्त चेकों के साथ):

function reflectPromise<T>(p: Promise<T>): Promise<
        { data: T, resolved: boolean, rejected?: undefined  } |
        { error: any, resolved?: undefined, rejected: boolean }
    > {
    return p.then((data: any) => ({
                data,
                resolved: true
            }))
            .catch((error: any) => ({
                error,
                rejected: true
            }));
}


(async function (somePromise: Promise<number>) {
    const result = await (reflectPromise(somePromise));
    const didReject = !!result.rejected
    if (result.rejected) {
        result.error // result is { error: any, resolved?: undefined, rejected: true }
    } else {
        result.data // result { data: number, resolved: true, rejected?: undefined  } 
    }

    if (result.resolved) {
        result.data // result { data: number, resolved: true, rejected?: undefined  } 
    } else {
        result.error // result is { error: any, resolved?: undefined, rejected: true }
    }
})(Promise.resolve(1));

इसके अलावा के कार्यान्वयन reflectPromiseदिखता है के साथ बेहतर async/awaitमेरी राय में:

async function reflectPromise<T>(p: Promise<T>): Promise<
    { data: T, resolved: true, rejected?: undefined } |
    { error: any, resolved?: undefined, rejected: true }
> {
    try {
        return {
            data: await p,
            resolved: true
        }
    } catch (e) {
        return {
            error: e,
            rejected: true
        }
    }
}

सख्त अशक्त चेकों के बिना, प्रकार गार्ड आंशिक रूप से अगर हम प्रकार थोड़ा बदलने के लिए, और दोनों निर्धारित करने की आवश्यकता के लिए काम करेंगे resolvedऔर rejectदोनों शाखाओं पर:

async function reflectPromise<T>(p: Promise<T>): Promise<
    { data: T, resolved: true, rejected: false } |
    { error: any, resolved: false, rejected: true }
> {
    try {
        return {
            data: await p,
            resolved: true,
            rejected: false,
        }
    } catch (e) {
        return {
            error: e,
            rejected: true,
            resolved: false
        }
    }
}

(async function (somePromise: Promise<number>) {
    const result = await (reflectPromise(somePromise));
    const didReject = !!result.rejected
    if (result.rejected) {
        result.error // result is { error: any, resolved?: undefined, rejected: true }
    } 

    if (result.resolved) {
        result.data // result { data: number, resolved: true, rejected?: undefined  } 
    }
})(Promise.resolve(1));