Tip annotating reflectPromise yöntemi

Question

Tip annotating reflectPromise yöntemi

oy

0

Ben bir sürümünü annoate yazmaya çalışıyordu reflect- buradan söz yöntemiyle https://stackoverflow.com/a/31424853/1828637

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

Ne yapar bir söz alır ve çözülmesi veya reddedilir başka söz döndürür.

şeyler ben pseudocode ile yapmaya çalışıyorum:

Beyan dataolduğunutypeof ResolveValue(p)
Beyan errorolduğunutypeof RejectValue(p)
Diğerleri test edebilirsiniz beyan const didReject = !!(await (reflectedPromise(somePromise)).rejected(bu döndüren çözülmesi vaatlerle için ne yapacağını { data: xxx, resolved:true }açmak edilir) undefinediçin true. Şu bulduğumda !!blah.rejectedtypescript bana diyorProperty 'rejected' does not exist on type

Bu defa ne var:

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

Oluştur 19/09/2018 saat 21:29
kaynak kullanıcı Noitidart

Diğer dillerde...

1 cevaplar

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

Sen anlaşılmaktadır sonuç türünü olması genel bir türünü kullanmak gerekir. Hatanın tipi olarak kabul edilir anydaktilo ve hiçbir tür güvenlik yoktur. Ayrıca ben yazarsınız rejectedve resolvedolarak undefineddeğil void(kendi değeri daha acurate yüzden zamanında sonuçta tanımsız edilecektir) ve mevcut değilken onları isteğe bağlı hale getirecektir.

Ayrıca zaman resolveve rejectvardır true, ben boolean türü olarak yeniden yazarsınız truetip korumalar daha iyi çalışmasını sağlamak amacıyla.

Bu (katı boş çekler ile) derler birlikte aktarmak:

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

Ayrıca uygulama reflectPromisedaha iyi olan görünüyor async/awaitBence:

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

Biz tipleri biraz değiştirmek ve her iki ayarlamak gerekiyorsa sıkı boş çekler olmadan, tip bekçi kısmen çalışacak resolvedve rejecther iki dallarda:

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