Padrões de Programação Funcional

Funções de alta ordem permitem padrões de programação funcional que tornam o código mais legível, de fácil manutenção e testável.

Métodos Principais de Array

Map - Transformar Cada Elemento

Transforme cada elemento em um array:

const numeros = [1, 2, 3, 4, 5];
const dobrados = numeros.map(x => x * 2);
// Resultado: [2, 4, 6, 8, 10]

const usuarios = [
  { nome: 'João', idade: 30 },
  { nome: 'Jane', idade: 25 },
];
const nomes = usuarios.map(usuario => usuario.nome);
// Resultado: ['João', 'Jane']

Filter - Selecionar Elementos

Filtre elementos com base em uma condição:

const numeros = [1, 2, 3, 4, 5, 6];
const numerosPares = numeros.filter(x => x % 2 === 0);
// Resultado: [2, 4, 6]

const adultos = usuarios.filter(usuario => usuario.idade >= 18);

Reduce - Combinar Elementos

Combine todos os elementos em um único valor:

const numeros = [1, 2, 3, 4, 5];
const soma = numeros.reduce((acc, x) => acc + x, 0);
// Resultado: 15

const agrupadoPorIdade = usuarios.reduce((acc, usuario) => {
  acc[usuario.idade] = acc[usuario.idade] || [];
  acc[usuario.idade].push(usuario);
  return acc;
}, {});

Criando Suas Próprias Funções de Alta Ordem

Implementação do forEach

function meuForEach(array, callback) {
  for (let i = 0; i < array.length; i++) {
    callback(array[i], i, array);
  }
}

meuForEach([1, 2, 3], x => console.log(x));

Implementação do map

function meuMap(array, callback) {
  const resultado = [];
  for (let i = 0; i < array.length; i++) {
    resultado.push(callback(array[i], i, array));
  }
  return resultado;
}

Composição de Funções

Combine múltiplas funções em uma:

const compor = (f, g) => x => f(g(x));

const adicionarUm = x => x + 1;
const dobrar = x => x * 2;

const adicionarUmDepoisDobrar = compor(dobrar, adicionarUm);
console.log(adicionarUmDepoisDobrar(3)); // 8 (3 + 1 = 4, 4 * 2 = 8)

Exemplos Práticos

Função Pipe

const pipe =
  (...funcoes) =>
  (valor) =>
    funcoes.reduce((acc, fn) => fn(acc), valor);

const pipeline = pipe(
  x => x + 1,
  x => x * 2,
  x => x - 3
);

console.log(pipeline(5)); // 9 ((5 + 1) * 2 - 3)

Memoização

Armazene em cache os resultados da função para melhorar o desempenho:

function memoizar(fn) {
  const cache = {};
  return function (...args) {
    const chave = JSON.stringify(args);
    if (chave in cache) {
      return cache[chave];
    }
    const resultado = fn.apply(this, args);
    cache[chave] = resultado;
    return resultado;
  };
}

const fibMemoizado = memoizar(function fib(n) {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
});