Apuntes sobre Javascript

JavaScript lo resuelve todo... eventualmente.

Funciones: bloques de código reutilizables

Hasta ahora has aprendido a trabajar con variables, operadores, condicionales y bucles. Pero a veces necesitas hacer la misma tarea en diferentes partes de tu programa, como saludar a un usuario o calcular un precio. Aquí entran las funciones, que son como pequeñas cápsulas que realizan una tarea y que puedes usar cuando quieras.

¿Qué son las funciones?

Una función es un bloque de código que realiza una tarea concreta y se puede reutilizar. Puedes pensar en una función como una receta: defines los pasos una vez (por ejemplo, cómo hacer un pastel) y luego la usas cada vez que la necesites, cambiando los ingredientes si quieres.

Una función se define una vez, con un nombre y unas instrucciones, y después se llama (o se invoca) cada vez que se quiere ejecutar. Puede recibir datos de entrada, los parámetros, y devolver un resultado.

1. Definir y llamar una función

Una función se crea con la palabra function, seguida de un nombre, unos paréntesis () y, entre llaves {}, el código que ejecuta. Definirla no la ejecuta: solo la deja preparada. Se ejecuta al llamarla, escribiendo su nombre seguido de los paréntesis:

function saludar() {
  console.log("¡Hola, bienvenido!");
}

saludar(); // Llama a la función: Imprime: ¡Hola, bienvenido!
saludar(); // Se puede llamar tantas veces como se quiera

2. Funciones con parámetros

Los parámetros son variables que la función recibe al llamarla, para hacer su tarea con datos distintos cada vez. Se escriben entre los paréntesis de la definición, y los valores, entre los paréntesis de la llamada:

function saludarPersona(nombre) {
  console.log("¡Hola, " + nombre + "!");
}

saludarPersona("Ana");    // Imprime: ¡Hola, Ana!
saludarPersona("Carlos"); // Imprime: ¡Hola, Carlos!

Puede haber varios, separados por comas, y se reciben en el mismo orden en que se pasan:

function sumar(a, b) {
  console.log(a + b);
}

sumar(5, 3);   // Imprime: 8
sumar(10, 20); // Imprime: 30

A diferencia de otros lenguajes, JavaScript no comprueba cuántos valores se pasan. Si falta alguno, el parámetro vale undefined, y si sobran, se ignoran, sin ningún aviso: sumar(1) imprime NaN, porque intenta sumar 1 y undefined. Si una función hace cosas raras, comprueba primero que la llamas con todos sus datos.

3. Funciones que devuelven valores

Muchas veces no interesa que la función imprima el resultado, sino que lo entregue para usarlo en otra parte del código: guardarlo en una variable, sumarlo a otra cosa, mostrarlo en la página. Para eso está return, que termina la función y devuelve un valor a quien la llamó:

function multiplicar(a, b) {
  let resultado = a * b;
  return resultado;
}

let total = multiplicar(4, 5);
console.log(total);             // Imprime: 20

console.log(multiplicar(3, 6)); // Imprime: 18

La función calcula primero el resultado y después lo devuelve. También se puede hacer en un solo paso, con return a * b;. Y la variable resultado de dentro de la función no tiene nada que ver con las de fuera: es local, como verás enseguida.

El código que va después de return no se ejecuta, porque return termina la función en ese mismo punto:

function ejemplo() {
  return "Terminé";
  console.log("Esto no se imprime nunca");
}

Un error clásico: olvidar el return

Basta con quitarle la última línea a la función de antes para que deje de servir:

function multiplicar(a, b) {
  let resultado = a * b;
  // falta: return resultado;
}

console.log(multiplicar(4, 5)); // Imprime: undefined
console.log(resultado);         // ReferenceError: resultado is not defined

La función hace bien la cuenta, pero el resultado se pierde por dos lados. Sin return, la función no devuelve nada, y su valor es undefined. Y la variable resultado no sirve de consuelo, porque solo existe dentro de la función: al terminar, desaparece. Pasa lo mismo con la función sumar de la sección anterior, que imprime pero no devuelve: let r = sumar(5, 3); muestra un 8 en la consola, pero r vale undefined.

4. El ámbito de las variables

Como viste en la lección de variables, una variable declarada dentro de una función es local: solo existe dentro de ella. Una declarada fuera de cualquier función es global, y la función puede usarla:

let global = "Soy global";

function miFuncion() {
  let local = "Soy local";
  console.log(global); // Imprime: Soy global
  console.log(local);  // Imprime: Soy local
}

miFuncion();
console.log(global); // Imprime: Soy global
// console.log(local); // ReferenceError: local is not defined

Que una función pueda usar las variables globales no significa que deba. Una función que lee y cambia variables de fuera es más difícil de entender y de reutilizar, porque su resultado depende de algo que no se ve en la llamada. Lo más limpio es que reciba lo que necesita por sus parámetros y entregue lo que produce con return.

5. Valores por defecto

A un parámetro se le puede dar un valor que se use cuando no se le pasa ninguno:

function saludarConEdad(nombre = "Invitado", edad = 0) {
  console.log("Hola, " + nombre + ", tienes " + edad + " años.");
}

saludarConEdad("Lucía", 25); // Imprime: Hola, Lucía, tienes 25 años.
saludarConEdad();            // Imprime: Hola, Invitado, tienes 0 años.

El valor por defecto solo se usa cuando el parámetro llega como undefined, es decir, cuando no se pasa. Si se pasa null o 0, se respeta ese valor. Es la misma idea que el operador ?? de la lección de operadores, solo que un poco más estricta.

6. Funciones flecha

Las funciones flecha (arrow functions) son una forma más corta de escribir funciones. Las verás con frecuencia en los ejemplos de las próximas lecciones, así que conviene conocerlas. Esta es la equivalencia con una función tradicional:

// Función tradicional
function sumar(a, b) {
  return a + b;
}

// La misma función, con flecha
const sumarFlecha = (a, b) => a + b;

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

La función flecha se guarda en una variable, normalmente con const, y se llama igual que cualquier otra. Las reglas de la forma corta:

  • Si el cuerpo es una sola expresión, se quitan las llaves {} y el return: el resultado se devuelve solo.
  • Si hay un solo parámetro, se pueden quitar los paréntesis.
  • Sin parámetros, los paréntesis son obligatorios: () => ...
const doble = n => n * 2;            // un parámetro
const saludar = () => "¡Hola!";      // sin parámetros
const multiplicar = (a, b) => a * b; // varios parámetros

console.log(doble(5));          // Imprime: 10
console.log(saludar());         // Imprime: ¡Hola!
console.log(multiplicar(3, 4)); // Imprime: 12

Si el cuerpo necesita varias líneas, se usan llaves y un return, igual que en una función tradicional:

const describir = (nombre, edad) => {
  let texto = `${nombre} tiene ${edad} años.`;
  return texto;
};
console.log(describir("Ana", 25)); // Imprime: Ana tiene 25 años.

Nota: Para devolver un objeto (lección 8) con la forma corta, hay que ponerlo entre paréntesis: () => ({ nombre: "Ana" }). Sin ellos, () => { nombre: "Ana" } devuelve undefined, porque JavaScript toma las llaves por el cuerpo de la función, no por un objeto.

Las funciones son valores

En JavaScript, una función es un valor más, como un número o un texto: se puede guardar en una variable (es lo que hace la función flecha) y se puede pasar a otra función. Es la diferencia entre escribir el nombre con paréntesis o sin ellos: saludar() ejecuta la función, y saludar, a secas, es la función misma.

const doble = n => n * 2;

console.log(doble(5)); // Imprime: 10 (la ejecuta)
console.log(doble);    // Muestra la función misma: en el navegador, su código (n => n * 2)

// Pasar una función a otra: map() aplica doble a cada elemento de la lista
console.log([1, 2, 3].map(doble)); // Imprime: [2, 4, 6]

Este último ejemplo es un adelanto: en la lección de arrays verás map() y otras funciones que reciben una función para aplicarla a cada elemento, y en la de eventos, cómo se le pasa una función al navegador para que la ejecute cuando el usuario haga clic. Por eso conviene tener claro desde ahora que una función se puede pasar de un sitio a otro como cualquier valor.

Buenas prácticas

  1. Nombres descriptivos: que el nombre diga qué hace la función (calcularTotal en lugar de hacerCosas). Suelen empezar por un verbo.
  2. Funciones cortas: una función debe hacer una sola tarea. Si crece mucho, divídela en otras más pequeñas.
  3. Datos por parámetros, resultado con return: mejor que leer y cambiar variables globales.
  4. Devolver mejor que imprimir: una función que devuelve el resultado sirve para más cosas que una que solo lo imprime.
  5. Comenta lo que no sea obvio: si la función es compleja, un comentario que explique qué hace y qué espera recibir.

Nota: Las funciones declaradas con function nombre() {} se pueden llamar incluso antes de la línea donde se escriben, porque JavaScript las prepara al cargar el código (en inglés, hoisting). Las funciones flecha y las guardadas en variables (const f = () => {}) no: hay que definirlas antes de usarlas, o se obtiene un error (Cannot access 'f' before initialization).

En la próxima lección: arrays, para almacenar y manipular listas de múltiples valores.

TOP