在TypeScript中的异步函数中返回承诺

据我所知，这两个函数在JavaScript中具有相同的行为：

const whatever1 = (): Promise<number> => {
    return new Promise((resolve) => {
        resolve(4);
    });
};

const whatever2 = async (): Promise<number> => {
    return new Promise((resolve) => {
        resolve(4);
    });
};

---

这是TypeScript中的错误，还是我对异步函数有误解？

当您执行

新承诺（（解析）…

时，推断的类型是

承诺

，因为您应该使用

新承诺（（解析）

）

有趣的是，这个问题只有在添加了

async

关键字时才会突出显示。我建议将这个问题报告给TS团队

有许多方法可以解决此问题。以下所有函数都具有相同的行为：

const whatever1 = () => {
    return new Promise<number>((resolve) => {
        resolve(4);
    });
};

const whatever2 = async () => {
    return new Promise<number>((resolve) => {
        resolve(4);
    });
};

const whatever3 = async () => {
    return await new Promise<number>((resolve) => {
        resolve(4);
    });
};

const whatever4 = async () => {
    return Promise.resolve(4);
};

const whatever5 = async () => {
    return await Promise.resolve(4);
};

const whatever6 = async () => Promise.resolve(4);

const whatever7 = async () => await Promise.resolve(4);

const whatever1=（）=>{
返回新承诺（（解决）=>{
决心（4）；
});
};
const whatever2=async（）=>{
返回新承诺（（解决）=>{
决心（4）；
});
};
const whatever3=async（）=>{
返回等待新承诺（（解决）=>{
决心（4）；
});
};
const whatever4=async（）=>{
返还承诺。决议（4）；
};
const whatever5=async（）=>{
返回等待承诺。解决（4）；
};
const whatever6=async（）=>Promise.resolve（4）；
const whatever7=async（）=>wait Promise.resolve（4）；

在IDE中，您将能够看到所有这些函数的推断类型都是

（）=>Promise

这很复杂

首先，在这段代码中

const p = new Promise((resolve) => {
    resolve(4);
});

p

的类型被推断为

Promise

。typescript github上有关于这一点的内容，因此可以说这是一个bug，因为显然（对于人类而言），

p

应该是

Promise

然后，

Promise

与

Promise

兼容，因为基本上承诺唯一的属性是

Then

方法，而

Then

在这两种承诺类型中都与方法兼容。这就是为什么

whatever1

中没有错误

但是

async

的目的是假装您处理的是实际值，而不是承诺，然后在

whatever2

中得到错误，因为

{}

显然与

数字

不兼容

因此，

async

行为是相同的，但目前需要一些变通方法来让typescript编译它。在创建这样的承诺时，您可以简单地提供显式泛型参数：

const whatever2 = async (): Promise<number> => {
    return new Promise<number>((resolve) => {
        resolve(4);
    });
};

const whatever2=async（）：Promise=>{
返回新承诺（（解决）=>{
决心（4）；
});
};

请注意，在第二个函数中使用

async

有点无用，因为该函数将立即返回一个承诺，并且不会阻塞执行。如果承诺函数中的某个地方存在拒绝，返回类型如何保持不变？

const whatever2 = async (): Promise<number> => {
    return new Promise<number>((resolve) => {
        resolve(4);
    });
};