Typ Kommentierung reflectPromise Methode

Question

Typ Kommentierung reflectPromise Methode

stimmen

0

Ich habe versucht , eine Version der eintippen annoate reflectvon hier versprechen Methode - https://stackoverflow.com/a/31424853/1828637

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

Was sie tut, ist nimmt ein Versprechen, und gibt ein weiteres Versprechen, wenn es aufgelöst oder abgelehnt wird.

Die Dinge, die ich versuche, mit Pseudo-Code zu tun:

Erklären , dass dataisttypeof ResolveValue(p)
Erklären , dass erroristtypeof RejectValue(p)
Erklären Sie, dass andere testen const didReject = !!(await (reflectedPromise(somePromise)).rejected(was dies für aufgelöste Versprechen tun wird, was zurückgibt { data: xxx, resolved:true }) ist wiederum undefinedzu true. Zur Zeit , als ich tun , !!blah.rejectedsagt Typoskript mirProperty 'rejected' does not exist on type

Das ist, was ich habe, so weit:

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

Veröffentlicht am 19/09/2018 um 21:29
quelle vom benutzer Noitidart

In anderen Sprachen...

1 antworten

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

Sie benötigen einen generischen Typ verwenden gefolgert den Typ des Ergebnisses zu haben. Die Art des Fehlers wird als anyin Maschinenschrift , und es gibt es keine Typsicherheit. Ich würde auch geben rejectedund resolvedals undefinednicht void(ihr Wert wird schließlich zur Laufzeit nicht definiert werden , damit es mehr acurate ist) und ich würde sie optional machen , wenn sie nicht vorhanden sind.

Auch wenn resolveund rejectsind true, würde ich sie als boolean wörtlichen Typen ein , trueum Typ-Wachen zu ermöglichen , besser zu arbeiten.

Um es zusammen, das (mit strengen null Kontrollen) kompiliert:

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

Auch die Umsetzung reflectPromisesieht besser mit async/awaitmeiner Meinung nach :

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

Ohne strenge null Kontrollen, wird Typ - Schutzteilweise arbeiten , wenn wir die Typen etwas ändern müssen, und legen Sie beide resolvedund rejectauf beiden Zweige:

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