μέθοδος σχολιασμό 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, θα ήθελα να τους πληκτρολογήσετε ως boolean κυριολεκτική τύπου trueπροκειμένου να καταστεί δυνατή τύπου φύλακες για να λειτουργήσει καλύτερα.

Κάνοντας μαζί, αυτό συγκεντρώνει (με αυστηρούς ελέγχους null):

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

Χωρίς αυστηρούς ελέγχους null, φύλακας του είδους θα λειτουργήσει εν μέρει, αν πρέπει να αλλάξετε τους τύπους λίγο, και που τόσο 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));