Parámetros y valores de retorno

¿Qué son los parámetros?

Los parámetros son los nombres que aparecen en la definición de una función. Actúan como variables locales temporales que reciben valores cuando la función es llamada. Piensa en ellos como "espacios vacíos" que la función necesita que llenes para poder trabajar.

Argumentos vs Parámetros

Es crucial entender la diferencia entre estos dos términos que a menudo se confunden:

Parámetros por defecto

En JavaScript moderno, puedes asignar valores por defecto a los parámetros. Esto significa que si no proporcionas un argumento, la función utilizará el valor predeterminado.

// Sin parámetro por defecto
function saludar(nombre) {
  console.log("Hola, " + nombre);
}
saludar(); // Imprime: "Hola, undefined"

// Con parámetro por defecto
function saludar(nombre = "visitante") {
  console.log("Hola, " + nombre);
}
saludar(); // Imprime: "Hola, visitante"
saludar("Carlos"); // Imprime: "Hola, Carlos"

Múltiples parámetros

Las funciones pueden aceptar tantos parámetros como necesites. Sepáralos con comas.

function calcularArea(rectangulo, altura) {
  return rectangulo * altura;
}

const area = calcularArea(5, 3);
console.log(area); // 15

Parámetros rest (...args)

Cuando no sabes cuántos argumentos recibirá una función, usa el operador rest (...). Este captura todos los argumentos restantes en un array.

function sumarTodo(...numeros) {
  let total = 0;
  for (let numero of numeros) {
    total += numero;
  }
  return total;
}

console.log(sumarTodo(1, 2, 3)); // 6
console.log(sumarTodo(10, 20, 30, 40, 50)); // 150
console.log(sumarTodo()); // 0

¿Qué son los valores de retorno?

Un valor de retorno es el resultado que una función produce después de ejecutarse. La palabra clave return especifica qué valor debe "salir" de la función.

function sumar(a, b) {
  return a + b;
}

const resultado = sumar(5, 3);
console.log(resultado); // 8

// Sin return, la función devuelve undefined
function saludar(nombre) {
  console.log("Hola, " + nombre);
}

const valor = saludar("Ana"); // Imprime: "Hola, Ana"
console.log(valor); // undefined

Return anticipado y múltiples returns

Puedes usar return en cualquier parte de la función para salir anticipadamente. Esto es útil para validaciones o condiciones tempranas.

function buscarUsuario(usuarios, nombre) {
  // Return anticipado: sale si no hay usuarios
  if (!usuarios || usuarios.length === 0) {
    return "No hay usuarios para buscar";
  }
  
  // Return anticipado: sale si el nombre está vacío
  if (!nombre) {
    return "El nombre es requerido";
  }
  
  // Buscar el usuario
  for (let usuario of usuarios) {
    if (usuario.nombre === nombre) {
      return usuario; // Usuario encontrado
    }
  }
  
  // Si llegó aquí, no lo encontró
  return null;
}

const usuarios = [
  { nombre: "Ana", edad: 25 },
  { nombre: "Carlos", edad: 30 }
];

console.log(buscarUsuario(usuarios, "Ana")); // { nombre: "Ana", edad: 25 }
console.log(buscarUsuario(usuarios, "Pedro")); // null
console.log(buscarUsuario([], "Ana")); // "No hay usuarios para buscar"

Funciones de una sola línea con return implícito

Las arrow functions tienen una forma concisa de retornar valores sin la palabra clave return explícita.

// Forma tradicional
const sumar = function(a, b) {
  return a + b;
};

// Arrow function con return implícito
const sumar = (a, b) => a + b;

// Importante: solo funciona sin llaves
const sumar = (a, b) => { a + b }; // ¡Devuelve undefined!

console.log(sumar(3, 4)); // 7

Destructuring en parámetros

Puedes desestructurar objetos o arrays directamente en los parámetros de la función.

// Destructuring de objeto como parámetro
function mostrarUsuario({ nombre, edad, ciudad = "Desconocida" }) {
  console.log(`${nombre} tiene ${edad} años y vive en ${ciudad}`);
}

const usuario = { nombre: "María", edad: 28 };
mostrarUsuario(usuario); // "María tiene 28 años y vive en Desconocida"

// Destructuring de array como parámetro
function procesarCoordenadas([x, y]) {
  return `X: ${x}, Y: ${y}`;
}

const coords = [10, 20];
console.log(procesarCoordenadas(coords)); // "X: 10, Y: 20"

Ejemplo práctico: Calculadora de propinas

Veamos cómo aplicar todos estos conceptos en un ejemplo real:

function calcularPropina({ cuenta, porcentaje = 15, personas = 1 }) {
  // Validaciones con return anticipado
  if (cuenta <= 0) {
    return { error: "La cuenta debe ser mayor que cero" };
  }
  
  if (personas <= 0) {
    return { error: "Debe haber al menos una persona" };
  }
  
  // Cálculos
  const montoPropina = (cuenta * porcentaje) / 100;
  const totalConPropina = cuenta + montoPropina;
  const propinasPorPersona = montoPropina / personas;
  const totalPorPersona = totalConPropina / personas;
  
  // Retornar objeto con todos los resultados
  return {
    montoPropina: montoPropina.toFixed(2),
    totalConPropina: totalConPropina.toFixed(2),
    propinasPorPersona: propinasPorPersona.toFixed(2),
    totalPorPersona: totalPorPersona.toFixed(2)
  };
}

// Uso de la función
const resultado = calcularPropina({ cuenta: 150, porcentaje: 20, personas: 3 });
console.log(resultado);
// { montoPropina: "30.00", totalConPropina: "180.00", propinasPorPersona: "10.00", totalPorPersona: "60.00" }

// Usando valores por defecto
const resultado2 = calcularPropina({ cuenta: 100 });
console.log(resultado2);
// 15% de propina, 1 persona por defecto

Patrón de retorno temprano

Este patrón consiste en verificar las condiciones de error al principio de la función:

1. Verifica todas las condiciones que harían fallar la función
2. Usa return inmediatamente si detectas un error
3. Continúa con la lógica principal solo si todas las validaciones pasan

function registrarEstudiante({ nombre, email, edad }) {
  // Validaciones primero
  if (!nombre || nombre.trim() === "") {
    return { exito: false, error: "El nombre es requerido" };
  }
  
  if (!email || !email.includes("@")) {
    return { exito: false, error: "Email inválido" };
  }
  
  if (edad < 18 || edad > 100) {
    return { exito: false, error: "La edad debe estar entre 18 y 100" };
  }
  
  // Si llegó aquí, todo está bien
  return {
    exito: true,
    estudiante: { nombre, email, edad },
    mensaje: "Estudiante registrado exitosamente"
  };
}

"El código limpio es el que lee la persona que lo escribió hace seis meses. Los parámetros bien nombrados son tu regalo a tu yo futuro."

Resumen práctico

function calcula(numero) {
  if (numero === 0) {
    return "Cero";
  }
  if (numero < 0) {
    return "Negativo";
  }
  return "Positivo";
}