Funções de Ordem Superior

5.1 Conceitos Básicos

Funções de ordem superior são um aspecto importante da programação funcional e amplamente utilizadas em JavaScript. Elas permitem escrever código mais abstrato, compacto e reutilizável.

O que são funções de ordem superior?

Funções de ordem superior (higher-order functions) são aquelas que aceitam outras funções como argumentos ou retornam funções como resultado. Elas permitem usar funções como objetos de primeira classe, possibilitando criar programas mais abstratos e modulares.

Exemplos de funções de ordem superior

1. Passar funções como argumentos.
2. Retornar funções de outras funções.

5.2 Passar funções como argumentos

Utilizando métodos embutidos em arrays

O JavaScript oferece muitos métodos embutidos para trabalhar com arrays, que são funções de ordem superior, como forEach(), map(), filter(), reduce() e outros.

1. Método forEach()

O método forEach() executa a função especificada uma vez para cada elemento do array.

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

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

2. Método map()

O método map() cria um novo array com os resultados da chamada de uma função fornecida para cada elemento do array.

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

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

3. Método filter()

O método filter() cria um novo array com todos os elementos que passam no teste implementado pela função fornecida.

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

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

4. Método reduce()

O método reduce() aplica uma função contra um acumulador e cada elemento no array (da esquerda para a direita) para reduzi-lo a um único valor.

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

      console.log(sum);
      // Vai mostrar: 15
    
  

5.3 Retornar funções de outras funções

Funções de ordem superior podem retornar outras funções, permitindo criar funções mais flexíveis e configuráveis.

1. Currying

Currying é o processo de transformar uma função que aceita vários argumentos em uma função que aceita um argumento e retorna uma nova função que aceita o próximo argumento e assim por diante.

Exemplo de currying:

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

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

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

2. Criando funções customizáveis

Funções de ordem superior permitem criar funções que podem ser customizadas com argumentos.

Exemplo:

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

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

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

5.4 Aplicação prática

Vamos ver uma aplicação prática das funções de ordem superior.

Função compose()

A função compose() possibilita combinar várias funções em uma só, que aplica elas em cadeia:

    
      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)); // Vai mostrar: 12 (primeiro adiciona 1 a 5, depois duplica o resultado)
    
  

Funções de ordem superior assíncronas

Funções de ordem superior assíncronas permitem trabalhar com operações assíncronas, como requisições a APIs ou trabalho com timers:

    
      function fetchData(callback) {
        setTimeout(() => {
          callback('Dados recebidos');
        }, 1000);
      }

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

      fetchData(processData);
      // Vai mostrar: Dados recebidos (após 1 segundo)