Saltar al contenido
Funciones

Parámetros

Lección 2 de 510 min4 ejercicios

Los parámetros son los nombres que una función usa para los datos que recibe; los argumentos, los valores que le pasas al llamarla. JavaScript es muy flexible aquí: no comprueba cuántos argumentos llegan ni de qué tipo. Esa libertad es cómoda, pero tiene reglas que conviene conocer.

Argumentos que faltan o sobran

function presentar(nombre, ciudad) {
  return `${nombre} vive en ${ciudad}`;
}

console.log(presentar("Ana", "Lima"));          // normal
console.log(presentar("Ana"));                  // falta uno: undefined
console.log(presentar("Ana", "Lima", "Perú"));  // sobra uno: se ignora

No hay error en ningún caso: los parámetros sin argumento valen undefined y los argumentos de más se descartan.

Valores por defecto

Un = después del parámetro le da un valor para cuando llegue undefined:

function saludar(nombre = "visitante", signo = "!") {
  return `Hola, ${nombre}${signo}`;
}

console.log(saludar());
console.log(saludar("Eva"));
console.log(saludar("Eva", "?"));
console.log(saludar(undefined, "?"));  // undefined usa el valor por defecto
console.log(saludar(null));            // null no: es un valor

El valor por defecto se calcula en cada llamada, y puede usar los parámetros anteriores: function crear(ancho, alto = ancho).

El parámetro rest

...nombre como último parámetro junta todos los argumentos restantes en un array:

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

console.log(sumarTodo(1, 2, 3, 4));
console.log(sumarTodo());

function etiquetar(etiqueta, ...items) {
  return items.map((i) => `${etiqueta}: ${i}`);
}
console.log(etiquetar("fruta", "pera", "uva"));

Es lo contrario del spread al llamar: Math.max(...lista) reparte un array en argumentos.

Objetos de opciones

Cuando una función tiene muchos parámetros opcionales, el orden se vuelve un problema: crearVentana(400, 300, true, false, "oscuro") no se entiende. La solución moderna es recibir un objeto y desestructurarlo, como viste en Desestructuración y spread:

function crearVentana({ ancho = 400, alto = 300, tema = "claro", modal = false } = {}) {
  return `${ancho}×${alto} · ${tema}${modal ? " · modal" : ""}`;
}

console.log(crearVentana({ tema: "oscuro", modal: true }));
console.log(crearVentana());

Cada opción tiene nombre, el orden no importa y las que no pasas toman su valor por defecto.

Cómo se pasan los argumentos

Pasar un argumento funciona como una asignación: el parámetro recibe una copia del valor. Con primitivos, una copia independiente; con objetos, una copia de la referencia, así que la función puede modificar el objeto original:

function renombrar(usuario) {
  usuario.nombre = "Cambiado";   // modifica el objeto de afuera
}

function reemplazar(usuario) {
  usuario = { nombre: "Nuevo" }; // solo cambia la variable local
}

const ana = { nombre: "Ana" };
reemplazar(ana);
console.log(ana.nombre);  // Ana
renombrar(ana);
console.log(ana.nombre);  // Cambiado

Por eso es buena práctica que las funciones no modifiquen los objetos que reciben: si necesitan cambiar algo, que devuelvan uno nuevo.

Resumen

  • Los argumentos que faltan valen undefined; los que sobran se ignoran.
  • param = valor da un valor por defecto, que se usa solo con undefined.
  • ...resto, siempre al final, junta los argumentos sobrantes en un array.
  • Con muchas opciones, recibe un objeto y desestructúralo con valores por defecto.
  • Los objetos se pasan por referencia compartida: la función puede modificarlos.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Lo que recibe una función

Elige una respuesta en cada pregunta.

  1. Si una función tiene dos parámetros y la llamas con uno, ¿qué vale el segundo?

  2. En function f(x = 10), ¿cuándo vale 10 x?

  3. ¿Qué es numeros en function sumar(...numeros)?

  4. Si pasas un objeto a una función y ella le cambia una propiedad, ¿cambia afuera?

Ordena la salida: Valores por defecto y rest

undefined, null y un array como argumento. Ordena lo que aparecería en la consola.

function crear(nombre = "anónimo", rol = "lector") {  return `${nombre}:${rol}`;} function contar(...valores) {  return valores.length;} console.log(crear());console.log(crear(undefined, "admin"));console.log(crear(null));console.log(contar(1, [2, 3], 4));

Consola, de arriba abajo

  1. null:lector
  2. anónimo:lector
  3. 3
  4. anónimo:admin

Detective: Un rest fuera de lugar

Este programa ni siquiera arranca. Encuentra la línea y elige el arreglo que mantiene la función útil.

Consola

log.js:1
function registrar(...mensajes, nivel) {
                   ^^^^^^^^^^^

SyntaxError: Rest parameter must be last formal parameter

Paso 1: toca la línea de código que causa el error.

Laboratorio: Un promedio flexible

Escribe promedio con un parámetro rest: recibe cualquier cantidad de números y, sin ninguno, devuelve 0.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 6 y después 0 (pendiente)
  • Funciona con otras cantidades: promedio(1, 2) da 1.5 (pendiente)
  • Usa un parámetro rest, sin arguments (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.