Funciones de orden superior

5.1 Conceptos básicos

Las funciones de orden superior son un aspecto importante de la programación funcional y se utilizan ampliamente en JavaScript. Permiten escribir código más abstracto, compacto y reutilizable.

¿Qué son las funciones de orden superior?

Las funciones de orden superior (higher-order functions) son funciones que toman otras funciones como argumentos o devuelven funciones como resultado. Permiten usar funciones como objetos de primera clase, lo que posibilita crear programas más abstractos y modulares.

Ejemplos de funciones de orden superior

1. Pasar funciones como argumentos.
2. Devolver funciones desde otras funciones.

5.2 Pasar funciones como argumentos

Uso de métodos de arrays incorporados

JavaScript proporciona muchos métodos incorporados para trabajar con arrays, los cuales son funciones de orden superior, como forEach(), map(), filter(), reduce() y otros.

1. Método forEach()

El método forEach() ejecuta una función proporcionada una vez por cada elemento del array.

    
      const numbers = [1, 2, 3, 4, 5];

      numbers.forEach(function(number) {
        console.log(number);
      });
      // Output: 1 2 3 4 5
    
  

2. Método map()

El método map() crea un nuevo array con los resultados de llamar a una función proporcionada en cada elemento del array.

    
      const numbers = [1, 2, 3, 4, 5];
      const squaredNumbers = numbers.map(function(number) {
        return number * number;
      });

      console.log(squaredNumbers);
      // Output: [1, 4, 9, 16, 25]
    
  

3. Método filter()

El método filter() crea un nuevo array con todos los elementos que pasan la prueba implementada por la función proporcionada.

    
      const numbers = [1, 2, 3, 4, 5];
      const evenNumbers = numbers.filter(function(number) {
        return number % 2 === 0;
      });

      console.log(evenNumbers);
      // Output: [2, 4]
    
  

4. Método reduce()

El método reduce() aplica una función a un acumulador y a cada elemento del array (de izquierda a derecha), reduciéndolo a un solo valor.

    
      const numbers = [1, 2, 3, 4, 5];
      const sum = numbers.reduce(function(total, number) {
        return total + number;
      }, 0);

      console.log(sum);
      // Output: 15
    
  

5.3 Devolver funciones desde otras funciones

Las funciones de orden superior pueden devolver otras funciones, lo cual permite crear funciones más flexibles y configurables.

1. Currying

Currying es el proceso de transformar una función que toma varios argumentos en una función que toma un solo argumento y devuelve una nueva función que toma el siguiente argumento y así sucesivamente.

Ejemplo de currying:

    
      function multiply(a) {
        return function(b) {
          return a * b;
        };
      }

      const multiplyByTwo = multiply(2);
      console.log(multiplyByTwo(5)); // Output: 10

      const multiplyByThree = multiply(3);
      console.log(multiplyByThree(5)); // Output: 15
    
  

2. Creación de funciones personalizables

Las funciones de orden superior permiten crear funciones que se pueden personalizar mediante argumentos.

Ejemplo:

    
      function createGreeting(greeting) {
        return function(name) {
          console.log(`${greeting}, ${name}!`);
        };
      }

      const sayHello = createGreeting('Hello');
      sayHello('Alice'); // Output: Hello, Alice!

      const sayHi = createGreeting('Hi');
      sayHi('Bob'); // Output: Hi, Bob!
    
  

5.4 Aplicación práctica

Veamos una aplicación práctica de las funciones de orden superior.

Función compose()

La función compose() permite combinar varias funciones en una sola que las aplica en cadena:

    
      function compose(...functions) {
        return function(initialValue) {
          return functions.reduceRight((value, func) => func(value), initialValue);
        };
      }

      const addOne = x => x + 1;
      const double = x => x * 2;
      const addOneAndDouble = compose(double, addOne);
      console.log(addOneAndDouble(5)); // Output: 12 (primero suma 1 a 5, luego duplica el resultado)
    
  

Funciones de orden superior asíncronas

Las funciones de orden superior asíncronas permiten trabajar con operaciones asíncronas, como solicitudes a API o trabajo con temporizadores:

    
      function fetchData(callback) {
        setTimeout(() => {
          callback('Data received');
        }, 1000);
      }

      function processData(data) {
        console.log(data);
      }

      fetchData(processData);
      // Output: Data received (después de 1 segundo)