Typescript 类型注释反射承诺方法

我试图从这里输入annoate

reflect

promise方法的一个版本-

它所做的是接受一个承诺，并在解决或拒绝时返回另一个承诺

我试图用伪代码做的事情：

声明

数据

是

类型的ResolveValue（p）

声明

error

是

typeof RejectValue（p）

声明其他人可以测试

const didreep=！！（wait（reflectedPromise（somePromise））.rejected

（这将为已解析的承诺做什么，它返回

{data:xxx，resolved:true}

）是将

未定义的
转换为
true
。当前我这样做时
！！废话。rejected
类型脚本对我说
类型上不存在属性“rejected”

这就是我到目前为止所做的：

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

函数反射承诺（p:Promise）：承诺<
{数据：任意，已解析：布尔，已拒绝：void}|
{错误：any，已解析：void，已拒绝：boolean}
> {
返回p.then（数据：任意）=>({
数据，
决定：正确
}))
.catch（（错误：任意）=>({
错误，
拒绝：正确
}));
}

您需要使用泛型类型来推断结果的类型。在Typescript中，错误类型被认为是

any

，没有类型安全性。此外，我会将

拒绝

和

解析

键入为

未定义

非

无效

（它们的值在运行时毕竟是未定义的，因此更为准确），当它们不存在时，我会将它们设置为可选

另外，当

resolve

和

reject

为

true

时，我会将它们键入布尔文本类型

true

，以便让类型保护更好地工作

将其放在一起编译（使用严格的空检查）：

没有严格的空检查，如果我们需要稍微更改类型，并且在两个分支上同时设置

已解析

和

拒绝

，则类型保护将部分工作：

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

异步函数reflectPromise（p:Promise）：Promise< {数据：T，已解析：true，已拒绝：false}| {错误：任意，已解决：false，已拒绝：true} > { 试一试{ 返回{ 数据：等待p， 决心：是的， 拒绝：错误， } }捕获（e）{ 返回{ 错误：e， 拒绝：对， 已解决：错误 } } } （异步函数（somePromise:Promise）{ const result=wait（reflectPromise（somePromise））； const didreep=！！result.rejected 如果（结果被拒绝）{ result.error//结果为{error:any，已解决？：未定义，已拒绝：true} } 如果（结果已解决）{ result.data//result{data:number，已解析：true，已拒绝？：未定义} } })（承诺。决议（1））；

---

您需要使用泛型类型来推断结果的类型。在Typescript中，错误类型被认为是

any

，没有类型安全性。此外，我会将

拒绝

和

解析

键入为

未定义

非

无效

（它们的值在运行时毕竟是未定义的，因此更为准确），当它们不存在时，我会将它们设置为可选

另外，当

resolve

和

reject

为

true

时，我会将它们键入布尔文本类型

true

，以便让类型保护更好地工作

将其放在一起编译（使用严格的空检查）：

没有严格的空检查，如果我们需要稍微更改类型，并且在两个分支上同时设置

已解析

和

拒绝

，则类型保护将部分工作：

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

异步函数reflectPromise（p:Promise）：Promise< {数据：T，已解析：true，已拒绝：false}| {错误：任意，已解决：false，已拒绝：true} > { 试一试{ 返回{ 数据：等待p， 决心：是的， 拒绝：错误， } }捕获（e）{ 返回{ 错误：e， 拒绝：对， 已解决：错误 } } } （异步函数（somePromise:Promise）{ const result=wait（reflectPromise（somePromise））； const didreep=！！result.rejected 如果（结果被拒绝）{ result.error//结果为{error:any，已解决？：未定义，已拒绝：true} } 如果（结果已解决）{ result.data//result{data:number，已解析：true，已拒绝？：未定义} } })（承诺。决议（1））；

---

Super谢谢您在这里的解释！我是打字新手，所以学到了很多。这是超级有用的我希望我可以给你更多的投票点！！特别是关于

void

的注释，以及严格的空值检查，它让我现在开始了解这些差异。非常感谢您在这里的解释！我是打字新手，所以学到了很多。这是超级有用的我希望我可以给你更多的投票点！！特别是关于

void

的注释，以及严格的空值检查，它让我现在开始了解这些差异。

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

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