如何设置拒绝我的承诺的类型？假设我这样做：
const start = (): Promise<string> => {
return new Promise((resolve, reject) => {
if (someCondition) {
resolve('correct!');
} else {
reject(-1);
}
});
}
假设我想用一个数字拒绝。但我无法设置类型；我可以在这里将任何我想要的东西传递给reject。
此外，在使用这个promise时，如果我错误地使用了拒绝响应类型，我希望有编译错误。
【问题讨论】：
标签： javascript typescript promise
您可以使用代理来显式强制使用 resolve 和 reject 参数类型。下面的例子并没有试图模仿 Promise 的构造函数——因为在实践中我没有发现它有用。我实际上希望能够将.resolve(...) 和.reject(...) 作为构造函数之外的函数调用。在接收方使用裸承诺 - 例如，await p.promise.then(...).catch(...)。
export type Promolve<ResT=void,RejT=Error> = {
promise: Promise<ResT>;
resolve: (value:ResT|PromiseLike<ResT>) => void;
reject:(value:RejT) =>void
};
export function makePromolve<ResT=void,RejT=Error>(): Promolve<ResT,RejT> {
let resolve: (value:ResT| PromiseLike<ResT>)=>void = (value:ResT| PromiseLike<ResT>)=>{}
let reject: (value:RejT)=>void = (value:RejT)=>{}
const promise = new Promise<ResT>((res,rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
}
let 语句看起来好像毫无意义——它们在运行时毫无意义。但它会阻止那些不容易解决的编译器错误。
(async()=>{
const p = makePromolve<number>();
//p.resolve("0") // compiler error
p.resolve(0);
// p.reject(1) // compiler error
p.reject(new Error('oops'));
// no attempt made to type the receiving end
// just use the named promise
const r = await p.promise.catch(e=>e);
})()
如图所示，对 .resolve 和 .reject 的调用已正确键入检查。
上面没有尝试在接收端强制进行类型检查。
我确实提出了这个想法，添加了.then 和.catch 成员，但是他们应该返回什么呢？如果他们返回一个Promise，那么它又回到了一个正常的承诺，所以这是没有意义的。似乎别无选择，只能这样做。所以裸承诺用于await、.then 和.catch。
【讨论】：
由于在某些情况下无法设置错误类型，例如 Promise 或异常抛出，我们可以处理类似 rust 风格的错误：
// Result<T, E> is the type used for returning and propagating errors.
// It is an sum type with the variants,
// Ok<T>, representing success and containing a value, and
// Err<E>, representing error and containing an error value.
export type Ok<T> = { _tag: "Ok"; ok: T };
export type Err<E> = { _tag: "Err"; err: E };
export type Result<T, E> = Ok<T> | Err<E>;
export const Result = Object.freeze({
Ok: <T, E>(ok: T): Result<T, E> => ({ _tag: "Ok", ok }),
Err: <T, E>(err: E): Result<T, E> => ({ _tag: "Err", err }),
});
const start = (): Promise<Result<string, number>> => {
return new Promise((resolve) => {
resolve(someCondition ? Result.Ok("correct!") : Result.Err(-1));
});
};
start().then((r) => {
switch (r._tag) {
case "Ok": {
console.log(`Ok { ${r.ok} }`);
break;
}
case "Err": {
console.log(`Err { ${r.err} }`);
break;
}
}
});
【讨论】：
.catch。你当然可以假设你的整个代码库只使用错误结果，但我向你保证，在任何规模很大的项目中，这种假设都会让你付出代价。
Result 可能是一个真正的 sum 类型，但 Promise 不是一个 monad，所以你真的不在 FP 领域。我已经走这条路太多次了，不仅是使用 TypeScript。老实说，我应该有点宽容，因为在有人为 TypeScript 中的异步编程创建真正的一元双函子之前，我每次看到Promise 这个词都会感到畏缩。如果上帝给我多一点时间，我会成为那个人。
@EstusFlask 在his answer 中提到的是正确的。
但是我想更接近人工解决方案 使用
TypeScript功能模拟我们想要的。
有时我在我的代码中使用这种模式?：
interface IMyEx{
errorId:number;
}
class MyEx implements IMyEx{
errorId:number;
constructor(errorId:number) {
this.errorId = errorId;
}
}
// -------------------------------------------------------
var prom = new Promise(function(resolve, reject) {
try {
if(..........)
resolve('Huuuraaa');
else
reject(new MyEx(100));
}
catch (error) {
reject(new MyEx(101));
}
});
// -------------------------------------------------------
prom()
.then(success => {
try {
}
catch (error) {
throw new MyEx(102);
}
})
.catch(reason=>{
const myEx = reason as IMyEx;
if (myEx && myEx.errorId) {
console.log('known error', myEx)
}else{
console.log('unknown error', reason)
}
})
【讨论】：
异常键入 any 因为我们不能保证正确 设计时异常的类型，既不是 TypeScript 也不是 JavaScript 提供了在运行时保护异常类型的能力。 最好的选择是使用类型保护在代码中提供设计时和运行时检查。
【讨论】：
正如this issue 中所述，Promise 没有不同类型的已履行和已拒绝承诺。 reject accepts any argument 不会影响承诺的类型。
目前无法更好地键入Promise。这是因为可以通过throwing 在then 或catch 中拒绝一个promise（这是拒绝现有promise 的更好方式），而这不能通过打字系统处理；还有，TypeScript also doesn't have exception-specific types except never。
【讨论】：