Funciones

Una función es un bloque de código con nombre que puedes guardar y ejecutar cuando quieras, tantas veces como necesites. Es la herramienta más importante para organizar programas: en lugar de repetir las mismas líneas una y otra vez, las escribes una sola vez y las llamas por su nombre.

Piensa en una receta: la escribes una vez (“batir, hornear, servir”) y cada vez que quieres el plato, sigues la receta con ingredientes distintos.

Objetivos

Al terminar esta lección deberías ser capaz de:

• Declarar y llamar (invocar) una función.
• Distinguir parámetros de argumentos.
• Usar return para devolver un valor.
• Entender el ámbito local de las variables dentro de una función.
• Usar parámetros por defecto cuando falte un argumento.
• Evitar los errores típicos al trabajar con funciones.

¿Para qué sirven?

Sin funciones, un programa que saluda a tres personas repetiría el mismo código tres veces:

sin-funciones.js

console.log("Hola, Ana");
console.log("Hola, Luis");
console.log("Hola, Marta");

Con una función, la lógica se escribe una vez:

con-funciones.js

function saludar(nombre) {
  console.log("Hola, " + nombre);
}

saludar("Ana");
saludar("Luis");
saludar("Marta");

Ventajas concretas:

Ventaja	Qué significa
Reutilizar	Escribes una vez, usas muchas.
Organizar	Cada función hace una tarea con nombre claro.
Corregir fácil	Si hay un error, lo arreglas en un solo sitio.
Probar por partes	Puedes comprobar cada función por separado.

Anatomía de una función

function saludar(nombre) {
  return "Hola, " + nombre;
}

Parte	Qué es	En el ejemplo
function	Palabra clave que declara la función	function
Nombre	Cómo la llamarás después	saludar
(nombre)	Lista de parámetros (datos que recibe)	nombre
{ ... }	Cuerpo: las instrucciones	return "Hola, " + nombre;
return	Valor que devuelve al terminar	"Hola, Ana"

Declarar la función no ejecuta nada. Para que ocurra algo hay que llamarla (o invocarla) escribiendo su nombre seguido de paréntesis:

llamar.js

function saludar(nombre) {
  return "Hola, " + nombre;
}

saludar("Ana"); // se ejecuta, pero el valor devuelto se pierde
console.log(saludar("Ana")); // "Hola, Ana" → ahora sí lo usamos

No confundas declarar con llamar

saludar (sin paréntesis) es la función en sí, un valor. saludar("Ana") (con paréntesis) es ejecutarla. Si escribes console.log(saludar) verás el código de la función, no un saludo.

Parámetros y argumentos

Se parecen, pero no son lo mismo:

• Parámetro: el nombre que aparece en la definición (la “casilla” de la receta). → nombre
• Argumento: el valor real que pasas al llamar (el “ingrediente”). → "Ana"

parametros-argumentos.js

function sumar(a, b) {
  // a y b son PARÁMETROS
  return a + b;
}

sumar(3, 5); // 3 y 5 son ARGUMENTOS → devuelve 8
sumar(10, 20); // otros argumentos, misma función → devuelve 30

Puedes tener cero, uno o muchos parámetros, separados por comas:

varios-parametros.js

function presentarse(nombre, edad, ciudad) {
  return `${nombre} tiene ${edad} años y vive en ${ciudad}`;
}

console.log(presentarse("Ana", 28, "Lima"));

Nota

Si llamas con menos argumentos de los esperados, los que faltan valen undefined (lo vimos en null y undefined). Si llamas con más, los extras simplemente se ignoran.

return: devolver un valor

return hace dos cosas a la vez:

1. Entrega un valor a quien llamó a la función.
2. Termina la función inmediatamente: lo que venga después no se ejecuta.

return.js

function esPar(numero) {
  return numero % 2 === 0;
  console.log("Esta línea nunca se ejecuta"); // detrás del return
}

console.log(esPar(4)); // true
console.log(esPar(7)); // false

Como la llamada produce un valor, puedes usarla dentro de otras operaciones:

usar-el-retorno.js

function doble(n) {
  return n * 2;
}

console.log(doble(5) + 1); // 11
console.log(doble(doble(3))); // 12 → una llamada dentro de otra

if (doble(4) > 5) {
  console.log("Es mayor que 5");
}

Si no hay return

Una función sin return devuelve undefined:

sin-return.js

function mostrarMensaje() {
  console.log("Hola");
}

const resultado = mostrarMensaje(); // imprime "Hola"
console.log(resultado); // undefined

El error más común

Escribir console.log(...) dentro de la función en vez de return. La función muestra el dato pero no lo devuelve, así que fuera obtienes undefined. Muestra y devuelve son cosas distintas.

mal-vs-bien.js

// ❌ Muestra pero no devuelve
function calcularIva(precio) {
  console.log(precio * 0.21);
}

// ✅ Devuelve para que otros puedan usarlo
function calcularIva(precio) {
  return precio * 0.21;
}

Parámetros por defecto

Puedes dar un valor de reserva por si no se pasa el argumento:

por-defecto.js

function saludar(nombre = "invitado") {
  return "Hola, " + nombre;
}

console.log(saludar("Ana")); // "Hola, Ana"
console.log(saludar()); // "Hola, invitado"

Como vimos en null y undefined, el valor por defecto se activa con undefined (o con la ausencia del argumento), pero no con null.

Ámbito: las variables de dentro se quedan dentro

Las variables declaradas dentro de una función son locales: no existen fuera.

ambito.js

function calcular() {
  const temporal = 42; // solo vive aquí
  return temporal * 2;
}

console.log(calcular()); // 84
console.log(temporal); // ❌ ReferenceError: temporal is not defined

Desde dentro sí puedes leer variables de fuera, pero no al revés:

ambito-exterior.js

const IVA = 0.21; // variable de fuera

function calcularTotal(precio) {
  return precio + precio * IVA; // ✅ se puede leer
}

console.log(calcularTotal(100)); // 121

Si una variable local se llama igual que una exterior, la local tapa a la otra:

shadowing.js

const mensaje = "de fuera";

function mostrar() {
  const mensaje = "de dentro";
  console.log(mensaje); // "de dentro"
}

mostrar();
console.log(mensaje); // "de fuera"

Consejo

Procura que las funciones dependan solo de sus parámetros y de constantes claras. Cuantas menos variables “de fuera” usen, más fáciles serán de entender y de reutilizar.

Ejemplo completo: una pequeña calculadora de pedido

pedido.js

const IVA = 0.21;

function calcularSubtotal(precio, cantidad) {
  return precio * cantidad;
}

function aplicarIva(subtotal) {
  return subtotal + subtotal * IVA;
}

function formatear(total) {
  return total.toFixed(2) + " €";
}

const subtotal = calcularSubtotal(12.5, 3); // 37.5
const total = aplicarIva(subtotal); // 45.375

console.log("Subtotal:", formatear(subtotal)); // "37.50 €"
console.log("Total:", formatear(total)); // "45.38 €"

Fíjate en la idea: tres funciones pequeñas con nombres que dicen exactamente qué hacen. Es mucho más fácil de leer (y de corregir) que un único bloque enorme.

Documentar funciones

Aquí encajan los comentarios JSDoc que vimos en la lección anterior:

jsdoc.js

/**
 * Devuelve true si el número es par.
 * @param {number} numero - Número a comprobar.
 * @returns {boolean} true cuando es par.
 */
function esPar(numero) {
  return numero % 2 === 0;
}

Errores frecuentes

Error	Qué pasa	Solución
Olvidar los () al llamar	Obtienes la función, no su resultado	Escribe saludar("Ana")
Usar console.log en vez de return	Fuera obtienes undefined	Devuelve el valor con return
Poner código después de return	Nunca se ejecuta	Colócalo antes
Confundir parámetro y argumento	El valor no llega donde esperas	Revisa definición y llamada
Leer una variable local fuera	ReferenceError	Devuélvela con return
Definir la función después de usarla	Código difícil de seguir	Declara antes de llamar

Ejercicio

1. Crea function areaRectangulo(base, altura) que devuelva el área y pruébala con dos medidas distintas.
2. Escribe esMayorDeEdad(edad) que devuelva true o false y úsala dentro de un if.
3. Escribe saludar(nombre = "invitado") y llámala con y sin argumento.
4. Escribe function triple(n) que devuelva n * 3 y úsala dentro de otro cálculo.
5. A propósito, cambia return por console.log en una función y comprueba qué obtienes al guardar su resultado en una variable.

Resumen

• Una función agrupa código con nombre para reutilizarlo; se declara una vez y se llama con ().
• Parámetros son los nombres en la definición; argumentos son los valores en la llamada.
• return entrega un valor y termina la función; sin return se obtiene undefined.
• Las variables declaradas dentro son locales; desde dentro se puede leer lo de fuera.
• Los parámetros por defecto (nombre = "invitado") cubren los argumentos ausentes.
• Conviene declarar la función antes de llamarla para que el código se lea de arriba abajo.

Cierre del módulo

¡Has llegado al final de Fundamentos del lenguaje! Con tipos, variables, condiciones, bucles y funciones ya tienes las piezas para construir programas completos. El mejor siguiente paso es practicar: coge los ejercicios de varias lecciones y combínalos en un proyecto pequeño.