Funciones

Una vez conocemos las bases de las funciones que hemos explicado en el tema de introducción funciones básicas, podemos continuar avanzando dentro del apartado de las funciones. En Javascript, las funciones son uno de los tipos de datos más importantes, ya que estamos continuamente utilizándolas a lo largo de nuestro código.

Y no, no me he equivocado ni he escrito mal el texto anterior; a continuación veremos que las funciones también pueden ser tipos de datos:

typeof(function() {});    // 'function'

Creación de funciones

Hay varias formas de crear funciones en Javascript: por declaración (la más usada por principiantes), por expresión (la más habitual en programadores con experiencia) o mediante constructor de objeto (no recomendada):

Constructor Descripción
Function function nombre(p1, p2...) { } Crea una función mediante declaración.
Function var nombre = function(p1, p2...) { } Crea una función mediante expresión.
Function new Function(p1, p2..., code); Crea una función mediante un constructor de objeto.
Funciones por declaración

Probablemente, la forma más popular de estas tres, y a la que estaremos acostumbrados si venimos de otros lenguajes de programación, es la primera, a la creación de funciones por declaración. Esta forma permite declarar una función que existirá a lo largo de todo el código:

function saludar() {
  return 'Hola';
}

saludar();          // 'Hola'
typeof(saludar);    // 'function'

De hecho, podríamos ejecutar la función saludar() incluso antes de haberla creado y funcionaría correctamente, ya que Javascript primero busca las declaraciones de funciones y luego procesa el resto del código.

Funciones por expresión

Sin embargo, en Javascript es muy habitual encontrarse códigos donde los programadores «guardan funciones» dentro de variables, para posteriormente «ejecutar dichas variables». Se trata de un enfoque diferente, creación de funciones por expresión, que fundamentalmente, hacen lo mismo con algunas diferencias:

// El segundo "saludar" (nombre de la función) se suele omitir: es redundante
var saludo = function saludar() {
  return 'Hola';
};

saludo();            // 'Hola'

Con este nuevo enfoque, estamos creando una función en el interior de una variable, lo que nos permitirá posteriormente ejecutar la variable (como si fuera una función). Observa que el nombre de la función (en este ejemplo: saludar) pasa a ser inútil, ya que si intentamos ejecutar saludar() nos dirá que no existe y si intentamos ejecutar saludo() funciona correctamente.

¿Qué ha pasado? Ahora el nombre de la función pasa a ser el nombre de la variable, mientras que el nombre de la función desaparece y se omite, dando paso a lo que se llaman las funciones anónimas (o funciones lambda).

Funciones como objetos

Como curiosidad, debes saber que se pueden declarar funciones como si fueran objetos. Sin embargo, es un enfoque que no se suele utilizar en producción. Simplemente es interesante saberlo para darse cuenta que en Javascript todo pueden ser objetos:

var saludar = new Function("return 'Hola';");

saludar();    // 'Hola'

Funciones anónimas

Las funciones anónimas o funciones lambda son un tipo de funciones que se declaran sin nombre de función y se alojan en el interior de una variable y haciendo referencia a ella cada vez que queramos utilizarla:

// Función anónima "saludo"
var saludo = function() {
  return 'Hola';
};

saludo;               // ƒ () { return 'Hola'; }
saludo();             // 'Hola'

Observa que en la última línea del ejemplo anterior, estamos ejecutando la variable, es decir, ejecutando la función que contiene la variable. Sin embargo, en la línea anterior hacemos referencia a la variable (sin ejecutarla, no hay paréntesis) y nos devuelve la función en sí.

La diferencia fundamental entre las funciones por declaración y las funciones por expresión es que estas últimas sólo están disponibles a partir de la inicialización de la variable. Si «ejecutamos la variable» antes de declararla, nos dará un error.

Callbacks

Ahora que conocemos las funciones anónimas, podremos comprender más fácilmente como utilizar callbacks (también llamadas funciones callback o retrollamadas). A grandes rasgos, un callback (llamada hacia atrás) es pasar una función B por parámetro a una función A, de modo que la función A puede ejecutar esa función B de forma genérica desde su código, y nosotros podemos definirlas desde fuera de dicha función:

// fB = Función B
var fB = function() {
  console.log('Función B ejecutada.');
};

// fA = Función A
var fA = function(callback) {
  callback();
}

fA(fB);

Esto nos podría permitir crear varias funciones para utilizar a modo de callback y reutilizarlas posteriormente con diferentes propósitos. De hecho, los callbacks muchas veces son la primera estrategia que se suele utilizar en Javascript para trabajar la asincronía, uno de los temas que veremos más adelante:

// fB = Función B (callback)
var fB = function() {
  console.log('Función B ejecutada.');
};

// fError = Función Error (callback)
var fError = function() {
  console.error('Error');
};

// fA = Función A
var fA = function(callback, callbackError) {
  var n = ~~(Math.random() * 5);
  if(n > 2)
    callback();
  else
    callbackError();
}

fA(fB, fError);   // Si ejecutamos varias veces, algunas darán error y otras no

Viendo este ejemplo, podemos planear ejecutar la función fA() cambiando los callbacks según nos interese, sin necesidad de crear funciones con el mismo código repetido una y otra vez. Además, en el caso de que las funciones callbacks sean muy cortas, muchas veces utilizamos directamente la función anónima, sin necesidad de guardarla en una variable previamente:

// fA = Función A
var fA = function(callback, callbackError) {
  var n = ~~(Math.random() * 5);
  if(n > 2)
    callback();
  else
    callbackError();
}

fA(function() {
  console.log('Función B ejecutada.');
}, function() {
  console.error('Error');
});

Aunque, como se puede ver, se suele evitar para facilitar la legibilidad del código, y sólo se utiliza en casos muy específicos donde estás seguro que no vas a reutilizar la función callback o no te interesa guardarla en una variable.

Funciones autoejecutables

Pueden existir casos en los que necesites crear una función y ejecutarla sobre la marcha. En Javascript es muy sencillo crear funciones autoejecutables. Básicamente, sólo tenemos que envolver entre paréntesis la función anónima en cuestión (no necesitamos que tenga nombre, puesto que no la vamos a guardar) y luego, ejecutarla:

// Función autoejecutable
(function () {
  console.log('Hola!!');
})();

// Función autoejecutable con parámetros
(function (name) {
  console.log(`¡Hola, ${name}!`);
})('Manz');

De hecho, también podemos utilizar parámetros en dichas funciones autoejecutables. Observa que sólo hay que pasar dichos parámetros al final de la función autoejecutable.

Ten en cuenta, que si la función autoejecutable devuelve algún valor con return, a diferencia de las funciones por expresión, en este caso lo que se almacena en la variable es el valor que devuelve la función autoejecutada:

var f = (function (name) {
  return `¡Hola, ${name}!`;
})('Manz');

f;          // '¡Hola, Manz!`
typeof(f);  // 'string'

Clausuras

Las clausuras o cierres, es un concepto relacionado con las funciones y los ámbitos que suele costar comprender cuando se empieza en Javascript. Es importante tener las bases de funciones claras hasta este punto, lo que permitirá entender las bases de una clausura.

A grandes rasgos, en Javascript, una clausura o cierre se define como una función que «encierra» variables en su propio ámbito (y que continúan existiendo aún habiendo terminado la función). Por ejemplo, veamos el siguiente ejemplo:

// Clausura: Función incr()
var incr = (function() {
  var num = 0;
  return function() { 
    num++;
    return num;
  }
})();

typeof(incr);     // 'function'
incr();           // 1
incr();           // 2
incr();           // 3

Tenemos una función anónima que es también una función autoejecutable. Aunque parece una función por expresión, no lo es, ya que la variable incr está guardando lo que devuelve la función anónima autoejecutable, que a su vez, es otra función diferente.

La «magia» de las clausuras es que en el interior de la función autoejecutable estamos creando una variable num que se guardará en el ámbito de dicha función, por lo tanto existirá con el valor declarado: 0.

Por lo tanto, en la variable incr tenemos una función por expresión que además conoce el valor de una variable num, que sólo existe dentro de incr. Si nos fijamos en la función que devolvemos, lo que hace es incrementar el valor de num y devolverlo. Como la variable incr es una clausura y mantiene la variable en su propio ámbito, veremos que a medida que ejecutamos incr(), los valores de num (que estamos devolviendo) conservan su valor y se van incrementando.

Arrow functions

Las Arrow functions, funciones flecha o «fat arrow» son una forma corta de escribir funciones que aparece en Javascript a partir de ECMAScript 6. Básicamente, se trata de reemplazar eliminar la palabra function y añadir => antes de abrir las llaves:

var func = function() {
  return "Función tradicional.";
};

var func = () => {
  return "Función flecha.";
};

Sin embargo, las funciones flechas tienen algunas ventajas a la hora de simplificar código bastante interesantes:

  • Si el cuerpo de la función sólo tiene una línea, podemos omitir las llaves ( {} ).
  • Además, en ese caso, automáticamente se hace un return de esa única línea, por lo que podemos omitir también el return.
  • En el caso de que la función no tenga parámetros, se indica como en el ejemplo anterior: () =>.
  • En el caso de que la función tenga un solo parámetro, se puede indicar simplemente el nombre del mismo: e =>.
  • En el caso de que la función tenga 2 ó más parámetros, se indican entre paréntesis: (a, b) =>.
  • Si queremos devolver un objeto, que coincide con la sintaxis de las llaves, se puede englobar con paréntesis: ({name: 'Manz'}).

Por lo tanto, el ejemplo anterior se puede simplificar aún más:

var func = () => "Función flecha.";    // 0 parámetros: Devuelve "Función flecha"
var func = e => e + 1;                 // 1 parámetro: Devuelve el valor de e + 1
var func = (a, b) => a + b;            // 2 parámetros: Devuelve el valor de a + b

Las funciones flecha hacen que el código sea mucho más legible y claro de escribir, mejorando la productividad y la claridad a la hora de escribir código.

Ámbito léxico de this

Aunque aún no la hemos utilizado, una de las principales diferencias de las funciones flecha respecto a las funciones tradicionales, es el valor de la palabra clave this, que no siempre es la misma.

Por ejemplo, si utilizamos una función de forma global en nuestro programa, no notaremos ninguna diferencia:

// Si son funciones globales
var a = function() {
  console.log(this);
};
var b = () => {
  console.log(this);
};

a();        // Window
b();        // Window

Sin embargo, si utilizamos una función en el interior de un objeto, como suele ser el caso más habitual, si encontraremos diferencias. Observa que en la primera función, donde se utiliza una función tradicional, el this devuelve el objeto padre de la función.

Por otro lado, en la segunda función, donde se utiliza una función flecha, el this no devuelve el objeto padre de la función, sino que devuelve Window.

padre = {
    a: function() {
      console.log(this);
    },
    b: () => {
      console.log(this);
    }
}

padre.a();  // padre
padre.b();  // Window

Esta es una diferencia clave que hay que tener bien en cuenta a la hora de trabajar con las funciones flecha. Una buena práctica es utilizar funciones tradicionales como las funciones de primer nivel y, luego, en su interior o en callbacks, utilizar funciones flecha.

Manz
Publicado por Manz

Docente, divulgador informático y freelance. Escribe en Emezeta.com, es profesor en la Oficina de Software Libre de la Universidad de La Laguna y dirige el curso de Programación web FullStack de EOI en Tenerife (Canarias). En sus ratos libres, busca GIF de gatos en Internet.