Tip Metoda adnotarea reflectPromise

Question

Tip Metoda adnotarea reflectPromise

voturi

0

Am încercat să tastați annoate o versiune a reflectmetodei de promisiune de aici - https://stackoverflow.com/a/31424853/1828637

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

Ceea ce face este nevoie de o promisiune, și returnează o altă promisiune când este rezolvată sau respins.

Lucrurile pe care le-am încercat să fac cu pseudocod:

Constatarea faptului că dataestetypeof ResolveValue(p)
Constatarea faptului că errorestetypeof RejectValue(p)
Declarați că alții pot testa const didReject = !!(await (reflectedPromise(somePromise)).rejected(ce acest lucru se va face pentru promisiuni rezolvate, care se întoarce { data: xxx, resolved:true }) se întoarce undefinedla true. În prezent , atunci când fac !!blah.rejectedtypescript spune - miProperty 'rejected' does not exist on type

Aceasta este ceea ce am până acum:

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

Întrebat 19/09/2018 la 21:29
sursa de către utilizator Noitidart

În alte limbi...

1 răspunsuri

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

Trebuie să utilizați un tip generic pentru a avea tipul de rezultat dedus. Tipul erorii este considerată anydactilografiat și nu există nici o siguranță de tip acolo. De asemenea , as scrie rejectedsi resolvedca undefinednu void(valoarea lor va fi nedefinită după toate în timpul rulării atât este mai acurate) și mi - ar face ei opțional , atunci când acestea nu sunt prezente.

De asemenea , atunci când resolveși rejectsunt true, le - aș tip ca tip literal boolean truepentru a permite agenților de tip să funcționeze mai bine.

Asamblând, acest compilează (cu controale stricte nule):

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));

De asemenea , punerea în aplicare a reflectPromisearata mai bine cu , async/awaitîn opinia mea:

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
        }
    }
}

Fără controale stricte nule, tipul de protecție va funcționa parțial dacă avem nevoie pentru a schimba tipurile un pic, și a stabilit atât resolvedși rejectpe ambele ramuri:

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));