¿Cómo configuro el tipo de rechazo de mi promesa? Digamos que sí:
const start = (): Promise<string> => { return new Promise((resolve, reject) => { if (someCondition) { resolve('correct!'); } else { reject(-1); } }); } Digamos que quiero rechazar con un número. Pero no puedo establecer el tipo; Puedo pasar lo que quiera al reject aquí.
Además, al usar esta promesa, quiero tener un error de compilación si uso el tipo de respuesta de rechazo incorrectamente.
Como se explica en este número , Promise no tiene diferentes tipos de promesas cumplidas y rechazadas. reject acepta any argumento que no afecte el tipo de una promesa.
Actualmente Promise no se puede escribir mejor. Esto resulta del hecho de que una promesa puede ser rechazada throw dentro de then o catch (esta es una forma preferible de rechazar una promesa existente), y esto no puede ser manejado por el sistema de escritura; Además, TypeScript tampoco tiene tipos específicos de excepción, excepto never .
Debido a que no hay forma de establecer el tipo de error en algunos casos, como Promesa, o lanzamientos de excepción, podemos trabajar con errores en estilo oxidado:
// 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; } } });La excepción se escribe any porque no podemos garantizar el tipo correcto de la excepción en el momento del diseño, y ni TypeScript ni JavaScript brindan la capacidad de proteger los tipos de excepción en el tiempo de ejecución. Su mejor opción es usar protectores de tipo para proporcionar una verificación en tiempo de diseño y tiempo de ejecución en su código.