Type de méthode reflectPromise annotant

Question

Type de méthode reflectPromise annotant

voix

0

J'ai essayé de taper annoate une version de la reflectméthode de promesse d'ici - https://stackoverflow.com/a/31424853/1828637

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

Ce qu'il fait est prend une promesse, et renvoie une autre promesse quand il est résolu ou rejetée.

Les choses que je suis en train de faire avec pseudocode:

Déclarez que dataesttypeof ResolveValue(p)
Déclarez que erroresttypeof RejectValue(p)
Déclarons que d' autres peuvent tester const didReject = !!(await (reflectedPromise(somePromise)).rejected(ce que cela va faire pour les promesses résolues, ce qui revient { data: xxx, resolved:true }) est à son tour undefinedà true. À l' heure actuelle , quand je fais !!blah.rejectedtapuscrit me ditProperty 'rejected' does not exist on type

Voilà ce que j'ai jusqu'à présent:

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

Créé 19/09/2018 à 21:29
source utilisateur Noitidart

Dans d'autres langues...

1 réponses

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

Vous devez utiliser un type générique pour avoir le type du résultat déduit. Le type de l'erreur est considérée anydactylographiée et il n'y a pas là la sécurité de type. Aussi je taperais rejectedet resolvedque undefinedpas void(leur valeur sera indéfini après tout à l' exécution il est donc plus acurate) et je les rendre facultative quand ils ne sont pas présents.

Aussi quand resolveet rejectsont true, je les type que le type littéral booléen trueafin de permettre de type gardes de mieux travailler.

Mettre ensemble, cette compile (avec des contrôles stricts nuls):

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

Aussi la mise en œuvre des reflectPromiseregards mieux avec , async/awaità mon avis:

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

Sans contrôles stricts null, la garde de type fonctionnera en partie si nous avons besoin de changer les types un peu, et mis à la fois resolvedet rejectsur les deux branches:

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