Funções de Ordem Superior

Funções de ordem superior são funções que podem receber outras funções como parâmetros e/ou retornar uma função como resultado. Este é um conceito poderoso que permite a criação de código mais modular, reutilizável e expressivo.

Passando Funções como Parâmetros

Em TypeScript, você pode definir o tipo de função que será passada como parâmetro, especificando o tipo dos argumentos e o tipo do valor de retorno da função. Isso proporciona segurança e clareza ao desenvolver.

Exemplo: Passando Funções como Parâmetros

Aqui está um exemplo simples de uma função de ordem superior que recebe uma função como parâmetro e a executa:

// Define o tipo de função que será aceita
type GreetFunction = (name: string) => string;

// Função de ordem superior que aceita uma função como parâmetro
function greetUser(greetFunction: GreetFunction, userName: string): void {
  console.log(greetFunction(userName));
}

// Função que será passada como parâmetro
const simpleGreet: GreetFunction = (name: string) => `Hello, ${name}!`;

// Chamando a função de ordem superior
greetUser(simpleGreet, "Alice"); // Saída: Hello, Alice!

Neste exemplo, greetUser é uma função de ordem superior que recebe uma função de saudação e um nome de usuário, e então chama a função de saudação com o nome do usuário.

Usando Callbacks

Funções de ordem superior são frequentemente usadas como callbacks, especialmente em operações assíncronas ou em bibliotecas como Array.

// Função que filtra um array com base em um critério de callback
function filterArray<T>(arr: T[], callback: (item: T) => boolean): T[] {
  const result: T[] = [];
  for (const item of arr) {
    if (callback(item)) {
      result.push(item);
    }
  }
  return result;
}

// Exemplo de uso com um callback
const numbers = [1, 2, 3, 4, 5];
const evenNumbers = filterArray(numbers, (num) => num % 2 === 0);
console.log(evenNumbers); // Saída: [2, 4]

Funções que Retornam Funções

Funções de ordem superior também podem retornar outras funções. Isso é útil para criar fábricas de funções ou funções que geram outras funções com base em parâmetros.

Exemplo: Funções que Retornam Funções

Aqui está um exemplo onde uma função retorna outra função:

// Função que retorna uma função
function createMultiplier(multiplier: number): (value: number) => number {
  return (value: number) => value * multiplier;
}

// Usando a função que retorna uma função
const double = createMultiplier(2);
const triple = createMultiplier(3);

console.log(double(5)); // Saída: 10
console.log(triple(5)); // Saída: 15

Neste exemplo, createMultiplier é uma função de ordem superior que retorna uma nova função que multiplica seu argumento pelo valor fornecido ao createMultiplier.

Currying

Currying é uma técnica funcional onde uma função com múltiplos argumentos é transformada em uma sequência de funções que cada uma recebe um único argumento.

// Função curried
function add(a: number): (b: number) => number {
  return (b: number) => a + b;
}

// Usando a função curried
const addFive = add(5);
console.log(addFive(3)); // Saída: 8
console.log(addFive(10)); // Saída: 15

Aqui, a função add é curried, permitindo criar novas funções específicas que adicionam um número fixo.

Benefícios das Funções de Ordem Superior

1. Reutilização de Código: Elas promovem a reutilização de código, permitindo a criação de funções mais gerais que podem ser customizadas com funções específicas.
2. Composição de Funções: Facilitam a composição de funções, onde funções menores podem ser combinadas para realizar tarefas mais complexas.
3. Abstração e Clareza: Ajudam a criar abstrações claras e reutilizáveis, tornando o código mais expressivo e fácil de entender.

Conclusão

Funções de ordem superior são um elemento essencial da programação funcional e são amplamente usadas em TypeScript para criar código modular, flexível e expressivo. Ao dominar o uso de funções como parâmetros e retornos, você pode escrever código mais poderoso e reutilizável, melhorando a manutenção e a clareza do seu projeto.