JavaScript
Explica cómo async y await construyen flujos sobre promesas, dónde se suspende una función y cómo manejar errores sin perder concurrencia.
Una función siempre retorna una Promise. suspende la continuación de esa función hasta que un valor se resuelva como promesa.
asyncawaitasync function loadProduct(productId) {
const product = await fetchProduct(productId);
return product;
}async function getValue() {
return 10;
}Es equivalente para el consumidor a:
function getValue() {
return Promise.resolve(10);
}getValue() instanceof Promise; // trueasync function validate(value) {
if (value < 0) {
throw new RangeError("Value cannot be negative");
}
return value;
}El consumidor recibe una promesa rechazada.
const value = await expression;Conceptualmente:
async function example() {
console.log("A");
await 10;
console.log("B");
}Aunque el valor no sea una promesa pendiente, la continuación posterior ocurre de forma asíncrona.
async function load() {
try {
return await loadData();
} catch (error) {
if (error instanceof NotFoundError) {
return null;
}
throw error;
}
}try...catch puede manejar el rechazo de una promesa esperada.
Sin manejo local:
async function load() {
return loadData();
}Suele ser suficiente.
Con try...catch o finally, return await puede ser necesario para que el rechazo ocurra dentro de esa estructura.
async function load() {
try {
return await loadData();
} catch (error) {
throw translateError(error);
}
}const user = await loadUser();
const orders = await loadOrders(user.id);La segunda operación depende de la primera, por lo que la secuencia tiene sentido.
const profile = await loadProfile();
const settings = await loadSettings();Si son independientes, esto espera dos veces.
const [profile, settings] = await Promise.all([
loadProfile(),
loadSettings(),
]);Secuencial deliberado:
for (const task of tasks) {
await runTask(task);
}Concurrente sin límite:
await Promise.all(tasks.map(runTask));Ninguna forma es universalmente mejor. Depende de orden, recursos, rate limits y efectos.
await items.forEach(async (item) => {
await saveItem(item);
});forEach retorna undefined; las promesas de sus callbacks no forman parte de su contrato.
Usa for...of o construye un array de promesas.
const promises = items.map(async (item) => {
return saveItem(item);
});
const results = await Promise.all(promises);Una callback async siempre retorna una promesa.
async function wrap(value) {
return value;
}Sigue creando una promesa. No uses async únicamente como decoración; cambia la API y el manejo de errores.
Los módulos pueden utilizar await en el nivel superior.
const configuration = await loadConfiguration();
export { configuration };Los módulos que dependen de este deben esperar su evaluación. Un top-level await innecesario puede retrasar un grafo completo y complicar ciclos.
async function load() {
try {
return await loadData();
} catch {
return [];
}
}Puede convertir un fallo de permisos o red en “no hay datos”. Solo usa fallbacks que conserven el significado.
async function checkout(order, services) {
const validatedOrder = validateOrder(order);
const reservation = await services.inventory.reserve(
validatedOrder.items,
);
try {
const payment = await services.payments.charge({
orderId: validatedOrder.id,
total: validatedOrder.total,
});
return {
reservation,
payment,
};
} catch (cause) {
await services.inventory.release(reservation.id);
throw new CheckoutError(
"Checkout could not be completed",
{ cause },
);
}
}La secuencia representa dependencias y compensación explícita.
¿Por qué await items.forEach(asyncCallback) no espera las operaciones?
Porque forEach ignora los valores retornados por sus callbacks y retorna undefined. await solo espera ese undefined normalizado, no las promesas internas.
Secuencialidad, concurrencia y límites explica cómo coordinar trabajo sin saturar recursos.