TypeScript
Tipado de funciones asíncronas y Promises, valores resueltos, errores, Awaited y composición de operaciones concurrentes en TypeScript.
Una función retorna una . TypeScript describe el valor con el que esa promesa puede cumplirse.
asyncPromiseasync function loadProduct(
productId: string,
): Promise<Product> {
return api.getProduct(productId);
}async function getValue(): Promise<number> {
return 10;
}Anotar number sería incorrecto: quien llama recibe una Promise.
async function getName() {
return "Nicolás";
}TypeScript infiere Promise<string>.
Promise<Product>describe el valor fulfilled. No declara el tipo del rechazo.
JavaScript puede rechazar con cualquier valor. Por eso un catch seguro comienza con unknown.
type ProductResult = Awaited<
ReturnType<typeof loadProduct>
>;
// ProductAwaited<T> modela cómo await adopta promesas y thenables, incluyendo anidamientos.
type AsyncValue<T> = T | PromiseLike<T>;Puede ser útil para APIs que aceptan valores normales o thenables. Para APIs propias, Promise<T> suele ser más claro si realmente prometes una promesa nativa.
type MaybePromise<T> = T | Promise<T>;
async function runHook<T>(
value: T,
hook: (value: T) => MaybePromise<void>,
): Promise<void> {
await hook(value);
}const [user, products] = await Promise.all([
loadUser(),
loadProducts(),
] as const);TypeScript conserva posiciones: user y products reciben tipos distintos.
En versiones modernas suele inferir bien un array literal sin as const, pero la precisión depende del contexto.
const results = await Promise.allSettled([
saveProduct(first),
saveProduct(second),
]);
for (const result of results) {
if (result.status === "fulfilled") {
console.log(result.value);
} else {
console.error(result.reason);
}
}reason continúa tipado de forma amplia porque los rechazos no tienen un tipo genérico obligatorio.
const promises = products.map(async (product) => {
return saveProduct(product);
});
// Promise<Product>[]
const saved = await Promise.all(promises);await products.forEach(async (product) => {
await saveProduct(product);
});El checker puede no impedirlo porque una función que retorna algo puede ser compatible con () => void. El error es del contrato runtime de forEach.
Usa:
for (const product of products) {
await saveProduct(product);
}O:
await Promise.all(products.map(saveProduct));Peligroso:
const product = await response.json() as Product;La assertion no valida.
const rawValue: unknown = await response.json();
const product = parseProduct(rawValue);type Result<T, TError> =
| { ok: true; value: T }
| { ok: false; error: TError };async function findProduct(
productId: string,
): Promise<Result<Product, ProductNotFound>> {
// ...
}Esto modela errores esperados como datos. Fallos inesperados todavía pueden rechazar.
async function* listProducts(): AsyncGenerator<
Product,
void,
unknown
> {
for await (const page of loadPages()) {
yield* page.products;
}
}Los tres parámetros representan valores producidos, retorno final y valores enviados a next.
async function requestJson<T>(
url: URL,
parse: (value: unknown) => T,
options: RequestInit = {},
): Promise<T> {
const response = await fetch(url, options);
if (!response.ok) {
throw new HttpError(response.status);
}
const value: unknown = await response.json();
return parse(value);
}El generic relaciona parser y resultado; no finge conocer la respuesta.
T en vez de Promise<T>.Promise<T, E>.forEach(async ...).Promise<any> en fronteras.PromiseLike con una promesa necesariamente nativa.async retorna Promise.Awaited extrae el resultado tras adopción.unknown y validación.¿Por qué Promise<Product> no garantiza que un rechazo sea ProductError?
Porque Promise solo parametriza el valor de cumplimiento. JavaScript permite rechazar con cualquier valor y TypeScript no añade un segundo parámetro obligatorio para errores.
Union types inicia el bloque de composición y narrowing.