O que são funções puras em JavaScript?

Funções puras são os elementos básicos da programação funcional. Eles são adorados por simplicidade e testabilidade.

Neste artigo, você encontrará uma lista de verificação que ajudará a determinar se uma função é pura ou não.

Lista de verificação

Uma função deve atender a duas condições para ser considerada "pura":

- Cada vez que a função retorna o mesmo resultado quando é chamada com o mesmo conjunto de argumentos

- sem efeitos colaterais

Vamos considerar em mais detalhes.

1. A mesma entrada => A mesma saída

Compare isto:

const add = (x, y) => x + y; add(2, 4); // 6 

Com isso:

 let x = 2; const add = (y) => { x += y; }; add(4); // x === 6 (the first time) 

No primeiro caso, o valor é retornado com base nos parâmetros especificados, independentemente de onde / quando você o chama.

Se você adicionar 2 e 4, você sempre obtém 6.

Nada afeta o resultado.

Funções impuras = resultados inconsistentes

O segundo exemplo não retorna nada. Ele confia nas condições gerais para realizar seu trabalho aumentando a variável fora de seu campo.

Este modelo é um pesadelo para os desenvolvedores.

O estado compartilhado introduz uma dependência de tempo. Você obtém resultados diferentes dependendo de quando você chamou a função. Na primeira vez que o resultado for 6, na próxima vez 10 e assim por diante.

Qual é melhor?

Nesse caso, você receberá menos bugs que aparecem apenas sob determinadas condições?

Nesse caso, é mais provável que você tenha sucesso em um ambiente multithread em que as dependências de tempo possam danificar o sistema?

Definitivamente no primeiro.

2. sem efeitos colaterais

Este teste é uma lista de verificação em si.

Exemplos de efeitos colaterais:

1. Modificação de parâmetros de entrada
2. console.log
3. Chamadas HTTP (AJAX / busca)
4. Alteração no sistema de arquivos
5. Solicitações de DOM

De fato, qualquer trabalho realizado por uma função não está relacionado ao cálculo do resultado final.

Eu aconselho você a assistir o vídeo de Bob Martin.

Aqui está uma função "suja" com um efeito colateral.

 const impureDouble = (x) => { console.log('doubling', x); return x * 2; }; const result = impureDouble(4); console.log({ result }); 

console.log aqui é um efeito colateral, mas não vai doer. Ainda obteremos os mesmos resultados, com os mesmos dados.

No entanto, isso pode causar problemas.

Mudança de objeto "impuro"

 const impureAssoc = (key, value, object) => { object[key] = value; }; const person = { name: 'Bobo' }; const result = impureAssoc('shoeSize', 400, person); console.log({ person, result }); 

A variável person foi alterada para sempre porque a função foi declarada por meio de uma instrução de atribuição.

Estado compartilhado significa que o impacto do impureAssoc não é mais completamente aparente. Compreender o efeito no sistema agora inclui rastrear todas as variáveis ​​que ele já tocou e conhecer seu histórico.

Estado compartilhado = dependências de tempo.

Podemos limpar o impureAssoc simplesmente retornando um novo objeto com as propriedades desejadas.

"Nós limpamos"

 const pureAssoc = (key, value, object) => ({ ...object, [key]: value }); const person = { name: 'Bobo' }; const result = pureAssoc('shoeSize', 400, person); console.log({ person, result }); 

Agora o PureAssoc retorna o resultado do teste, assim você não precisa se preocupar se ele mudar em outro lugar.

Isso poderia ser feito assim:

 const pureAssoc = (key, value, object) => { const newObject = { ...object }; newObject[key] = value; return newObject; }; const person = { name: 'Bobo' }; const result = pureAssoc('shoeSize', 400, person); console.log({ person, result }); 

Alterar a entrada pode ser perigoso, mas alterar a cópia não é um problema. O resultado final é uma função testável e previsível que funciona independentemente de onde e quando você o chamar.

As alterações são limitadas a essa pequena área e você ainda está retornando o valor.

Sumário

• Uma função é pura se não tiver efeitos colaterais e sempre retornará o mesmo resultado quando for chamada com o mesmo conjunto de argumentos.
• Os efeitos colaterais incluem: alteração da entrada, chamadas HTTP, gravação no disco, saída na tela.
• Você pode clonar com segurança e alterar os parâmetros de entrada. Apenas deixe o original inalterado.
• Sintaxe de distribuição (... sintaxe) é a maneira mais fácil de clonar objetos e matrizes.