Type kommentere reflectPromise metode

Question

Type kommentere reflectPromise metode

stemmer

0

Jeg prøvde å skrive annoate en versjon av reflectløftet metoden herfra - https://stackoverflow.com/a/31424853/1828637

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

Hva den gjør er tar et løfte, og returnerer en annen løftet når det er løst eller avvist.

De tingene jeg prøver å gjøre med pseudokode:

Erklærer at dataertypeof ResolveValue(p)
Erklærer at errorertypeof RejectValue(p)
Erklærer at andre kan teste const didReject = !!(await (reflectedPromise(somePromise)).rejected(hva dette vil gjøre for løst løfter, som returnerer { data: xxx, resolved:true }) er å slå undefinedtil true. For øyeblikket når jeg gjør !!blah.rejectedLoggfila sier til megProperty 'rejected' does not exist on type

Dette er hva jeg har så langt:

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

Publisert på 19/09/2018 klokken 21:29
kilden bruker Noitidart

På andre språk...

1 svar

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

Du må bruke en generisk type å ha den type resultatet utledes. Typen feilen regnes anyi typescript, og det er ingen type sikkerhet der. Også jeg ville skrive rejectedog resolvedsom undefinedikke void(verdien vil være udefinert tross alt under kjøring så det er mer acurate), og jeg ville gjøre dem ekstra når de ikke er tilstede.

Også når resolveog rejecter true, jeg ville skrive dem som boolean bokstavelig typen truefor å tillate type-vakter til å fungere bedre.

Sette det sammen, sammenstiller dette (med strenge null kontroller):

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

Også gjennomføringen av reflectPromiseutseende bedre med async/awaitetter min mening:

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

Uten strenge null sjekker, vil typen vakt delvis fungere hvis vi trenger å endre typen litt, og satt begge resolvedog rejectpå begge grener:

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