JavaScript
Explica cómo return entrega resultados y termina funciones, qué ocurre sin retorno explícito y cómo mantener contratos consistentes entre caminos.
return termina la ejecución de una función y entrega un valor al lugar donde fue llamada.
function add(first, second) {
return first + second;
}
const result = add(2, 3);function add(first, second) {
console.log(first + second);
}
const result = add(2, 3);
console.log(result); // undefinedconsole.log muestra información, pero no entrega ese valor a la llamada.
La versión reutilizable retorna el resultado:
function add(first, second) {
return first + second;
}Después quien llama decide qué hacer:
const result = add(2, 3);
console.log(result);
saveResult(result);Toda función devuelve algo. Si no ejecuta un return con valor, devuelve undefined.
function greet() {
console.log("Hello");
}
console.log(greet()); // undefinedTambién puede escribirse un retorno vacío:
function stopIfInvalid(value) {
if (value < 0) {
return;
}
processValue(value);
}Ese return termina la función y devuelve undefined.
function example() {
return "Finished";
console.log("This never runs");
}Todo lo que aparece después del retorno en el mismo camino es inalcanzable.
Un retorno temprano permite detener la función cuando una condición impide continuar.
function processOrder(order) {
if (!order) {
return { ok: false, reason: "Order is required" };
}
if (order.items.length === 0) {
return { ok: false, reason: "Order is empty" };
}
return { ok: true, total: calculateTotal(order.items) };
}Esto evita anidar todo el camino válido dentro de varios if.
Una función puede tener varios return, pero cada llamada solo ejecuta uno.
function getStockStatus(stock) {
if (stock === 0) {
return "out-of-stock";
}
if (stock <= 5) {
return "low-stock";
}
return "available";
}Los retornos deben mantener un contrato comprensible. Devolver tipos sin relación puede volver difícil usar la función.
function findUser(id) {
if (!id) return false;
if (!database.has(id)) return "not-found";
return database.get(id);
}Una alternativa más consistente:
function findUser(id) {
if (!id) {
return { ok: false, reason: "invalid-id" };
}
const user = database.get(id);
if (!user) {
return { ok: false, reason: "not-found" };
}
return { ok: true, user };
}Una función puede devolver cualquier valor.
function createSummary(order) {
return {
id: order.id,
total: calculateTotal(order.items),
};
}function getActiveProducts(products) {
return products.filter((product) => product.isActive);
}El valor devuelto puede ser nuevo o una referencia existente. El contrato debe dejar claro si el resultado puede modificarse sin afectar datos externos.
Las funciones también son valores.
function createMultiplier(multiplier) {
return function multiply(value) {
return value * multiplier;
};
}
const double = createMultiplier(2);
console.log(double(5)); // 10Este patrón conecta funciones de orden superior y closures.
const double = (number) => number * 2;La expresión se retorna automáticamente.
Con llaves, return vuelve a ser necesario:
const double = (number) => {
number * 2;
};
console.log(double(5)); // undefinedNo coloques el valor retornado en una línea nueva después de return.
function createUser() {
return
{
name: "Nicolás",
};
}JavaScript puede interpretar:
return;La función devuelve undefined.
Escribe el valor en la misma línea:
function createUser() {
return {
name: "Nicolás",
};
}Un return solo termina la función donde aparece.
function findActiveUser(users) {
users.forEach((user) => {
if (user.isActive) {
return user;
}
});
return null;
}El return user termina el callback de forEach, no findActiveUser. La función exterior sigue y devuelve null.
Para buscar un elemento:
function findActiveUser(users) {
return users.find((user) => user.isActive) ?? null;
}Una función async envuelve el valor retornado en una promesa.
async function getValue() {
return 10;
}
const result = getValue();
console.log(result instanceof Promise); // trueEl bloque de asincronía profundizará este comportamiento.
function divide(first, second) {
if (second === 0) {
throw new RangeError("Cannot divide by zero");
}
return first / second;
}return representa una salida normal. throw interrumpe el flujo mediante un error. Elegir depende del contrato y de si el caso forma parte de los resultados esperados.
function calculateLine(item) {
if (!item) {
return { ok: false, reason: "item-required" };
}
if (!Number.isInteger(item.quantity) || item.quantity <= 0) {
return { ok: false, reason: "invalid-quantity" };
}
const subtotal = item.price * item.quantity;
return {
ok: true,
line: {
productId: item.productId,
quantity: item.quantity,
subtotal,
},
};
}Todos los caminos devuelven una estructura compatible con una propiedad ok.
console.log con return.undefined.return.return al utilizar llaves en una arrow function.return entrega un valor y termina la función actual.undefined.console.log observa; return comunica un resultado.¿Qué devuelve findValue?
function findValue(values) {
values.forEach((value) => {
if (value === 3) {
return value;
}
});
return "not-found";
}
findValue([1, 2, 3]);Devuelve "not-found". El return value solo termina el callback actual de forEach.
Rest parameters explica cómo representar de forma explícita una cantidad variable de argumentos dentro de un array real.