const helloWorld = () => { console.log("Hello, World"); // Hello, World};helloWorld();Funções de retorno de chamada
Funções de retorno de chamada são funções que são passadas para outras funções como argumentos e são chamadas pela função na qual são passadas.
Simplesmente, funções de retorno de chamada são funções que escrevemos como argumentos em outras funções. Não podemos invocar funções de retorno de chamada. Eles são chamados quando a função principal na qual eles foram passados como argumentos é chamada.
Vejamos um exemplo:
const testValue = (value, test) => { if (test(value)) { return `${value} passed the test`; } else return `${value} did not pass the test`;};const checkString = testValue('Twitter', string => typeof string === 'string');checkString; // Twitter passed the testtestValue é uma função que aceita um valor e uma função de retorno de chamada test que retorna “valor passou no teste” se o valor retornar verdadeiro quando passado para a função de retorno de chamada.
Neste caso, a função de retorno de chamada é o segundo argumento que passamos para o testValue função. É invocado quando o testValue função é chamada.
Funções de ordem superior
Funções de ordem superior são funções que recebem outras funções como argumentos ou retornam uma função.
Neste artigo, irei elaborar mais sobre as funções de ordem superior e por que são uma provisão tão poderosa. Por enquanto, tudo que você precisa saber é que esses tipos de funções recebem outras funções como argumentos ou funções de retorno.
Funções Assíncronas
Funções assíncronas são funções que não têm nome e não podem ser reutilizadas. Essas funções são normalmente escritas quando precisamos realizar algo uma vez e em apenas um lugar.
Um exemplo perfeito de uma função assíncrona é o que escrevemos anteriormente neste artigo.
const checkString = testValue('Twitter', value => typeof value === 'string');checkString;// Refer to previous code snippetcheckString é uma variável cujo valor é uma função. Passamos dois argumentos para esta função.
'Twitter' é o primeiro argumento e o segundo é uma função assíncrona. Esta função não tem um nome e apenas uma tarefa: verificar se o valor fornecido é uma string.
Princípios de Programação Funcional
No início do artigo, aludi ao fato de que apenas usar funções não se traduz em programação funcional.
Existem alguns princípios que precisamos entender para que nossos programas se qualifiquem para o padrão de programação funcional. Vamos dar uma olhada nisso.
Evite mutações e efeitos colaterais.
O primeiro princípio da programação funcional é evitar mudanças nas coisas. Uma função não deve mudar nada, como uma variável global.
Isso é muito importante porque as alterações geralmente levam a bugs. Se uma função muda uma variável global, por exemplo, pode levar a um comportamento inesperado em todos os lugares onde essa variável é usada.
O segundo princípio é que uma função deve ser pura, o que significa que não tem efeitos colaterais. Na programação funcional, as alterações feitas são chamadas de mutações e os resultados são chamados de efeitos colaterais.
Uma função pura não faz nenhum dos dois. Uma função pura sempre terá a mesma saída para a mesma entrada.
Se uma função depende de uma variável global, essa variável deve ser passada para a função como um argumento. Isso nos permite obter a mesma saída para a mesma entrada.
Aqui está um exemplo:
const legalAgeInTheUS = 21;const checkLegalStatus = (age, legalAge) => { return age >= legalAge ? 'Of legal age.' : 'Not of legal age.';};const johnStatus = checkLegalStatus(18, legalAgeInTheUS);johnStatus; // Not of legal agelegalAgeInTheUS; // 21Abstração
Abstrações ocultam detalhes e nos permitem falar sobre problemas em um nível mais alto, sem descrever todos os detalhes de implementação do problema.
Usamos abstrações em quase todos os aspectos de nossas vidas, especialmente na fala.
Por exemplo, em vez de dizer “Vou trocar dinheiro por uma máquina que, uma vez ligada, exibe imagens em movimento acompanhadas de som”, é mais provável que você diga “Vou comprar uma televisão”.
Nesse caso Comprar e televisão são abstrações. Essas formas de abstração tornam a fala muito mais fácil e reduzem as chances de dizer a coisa errada.
Mas você vai concordar comigo que antes de usar termos abstratos como Comprar você precisa primeiro entender o significado do termo e o problema que ele abstrai.
As funções nos permitem alcançar algo semelhante. Podemos criar funções para tarefas que provavelmente repetiremos continuamente. Funções nos permitem criar nossas próprias abstrações.
Além de criar nossas próprias abstrações, algumas funções já foram criadas para que possamos abstrair tarefas que provavelmente faremos repetidas vezes.
Portanto, vamos examinar algumas dessas funções de ordem superior que já existem para abstrair tarefas repetitivas.
Filtrando matrizes
Ao trabalhar com estruturas de dados como arrays, é mais provável que nos encontremos em uma situação em que estamos interessados apenas em determinados itens do array.
Para obter esses itens, podemos criar facilmente uma função para fazer a tarefa:
function filterArray(array, test) { const filteredArray = []; for (let item of array) { if (test(item)) { filteredArray.push(item); } } return filteredArray;};const mixedArray = [1, true, null, "Hello", undefined, "World", false];const onlyStrings = filterArray(mixedArray, item => typeof item === 'string');onlyStrings; // ['Hello', 'World']filterArray é uma função que aceita uma matriz e uma função de retorno de chamada. Ele percorre a matriz e adiciona os itens que passam no teste na função de retorno de chamada em uma matriz chamada filteredArray.
Usando esta função, somos capazes de filtrar uma matriz e retornar itens nos quais estamos interessados, como no caso de mixedArray.
Imagine se tivéssemos 10 programas diferentes e em cada programa precisássemos filtrar um array. Mais cedo ou mais tarde, seria extremamente cansativo reescrever a mesma função repetidamente.
Felizmente alguém já pensou sobre isso. Matrizes têm um padrão filter método. Ele retorna uma nova matriz com os itens na matriz que recebe que passam no teste que fornecemos.
const mixedArray = [1, true, null, "Hello", undefined, "World", false];const stringArray = mixedArray.filter(item => typeof item === 'string')stringArray; // ['Hello', 'World']Usando o método de filtro padrão, fomos capazes de obter os mesmos resultados que alcançamos quando definimos nossa própria função no exemplo anterior. Portanto, o método de filtro é uma abstração da primeira função que escrevemos.
Transformando itens da matriz com mapa
Imagine outro cenário em que temos uma matriz de itens, mas gostaríamos de realizar uma determinada operação em todos os itens. Podemos escrever uma função para fazer isso por nós:
function transformArray(array, test) { const transformedArray = []; for (let item of array) { transformedArray.push(test(item)); } return transformedArray;};const ages = [12, 15, 21, 19, 32];const doubleAges = transformArray(ages, age => age * 2);doubleAges; // [24, 30, 42, 38, 64];Da mesma forma, criamos uma função que percorre qualquer array e transforma todos os itens do array com base na função de callback que fornecemos.
Mas, novamente, isso se tornaria tedioso se tivéssemos que reescrever a função em 20 programas diferentes.
Novamente, alguém pensou sobre isso para nós, e felizmente os arrays têm um método padrão chamado map que faz exatamente a mesma coisa. Ele aplica a função de retorno de chamada em todos os itens na matriz fornecida e, em seguida, retorna uma nova matriz.
const ages = [12, 15, 21, 19, 32];const doubleAges = ages.map(age => age * 2);doubleAges; // [24, 30, 42, 38, 64];Reduzindo Matrizes com Reduzir
Aqui está outro cenário: você tem uma matriz de números, mas gostaria de calcular a soma de todos esses números e retorná-la. Claro que você pode escrever uma função para fazer isso por você.
function reduceArray(array, test, start) { let sum = start; for (let item of array) { sum = test(sum, item) } return sum;}let numbers = [5, 10, 20];let doubleNumbers = reduceArray(numbers, (a, b) => a + b, 0);doubleNumbers; // 35Semelhante aos exemplos anteriores que acabamos de ver, os arrays têm um padrão reduce método que tem a mesma lógica que a função que acabamos de escrever acima.
O método de redução é usado para reduzir uma matriz a um único valor com base na função de retorno de chamada que fornecemos. Ele também leva um segundo argumento opcional que especifica de onde queremos que a operação no retorno de chamada comece.
A função de retorno de chamada que fornecemos na função de redução tem dois parâmetros. O primeiro parâmetro é o primeiro item da matriz por padrão. Caso contrário, é o segundo argumento que fornecemos no método de redução. O segundo parâmetro é o item atual na matriz.
let numbers = [5, 10, 20];let doubleNumbers = numbers.reduce((a, b) => a + b, 10);doubleNumbers; // 45//The above example uses the reduce method to add all the items in the array starting from 10.Outros métodos de array úteis
Array.some ()
Todos os arrays têm o some método que aceita uma função de retorno de chamada. Retorna true E se qualquer elemento na matriz passa no teste fornecido na função de retorno de chamada. Caso contrário, ele retorna false:
const numbers = [12, 34, 75, 23, 16, 63]console.log(numbers.some(item => item < 100)) // trueArray.every ()
O método every é o oposto do método some. Ele também aceita uma função de retorno de chamada e retorna true E se tudo os itens na matriz passam no teste fornecido na função de retorno de chamada. Caso contrário, ele retorna false:
const numbers = [12, 34, 75, 23, 16, 63]console.log(numbers.every(item => item < 100)) // trueArray.concat ()
o concat método, abreviação de concatenate, é um método de matriz padrão que concatena ou junta duas matrizes e retorna uma nova matriz:
const array1 = ['one', 'two', 'three'];const array2 = ['four', 'five', 'six'];const array3 = array1.concat(array2);array3; // [ 'one', 'two', 'three', 'four', 'five', 'six' ]Array.slice ()
o slice método é um método de array que copia os itens de um array de um determinado índice e retorna um novo array com os itens copiados. o slice método aceita dois argumentos.
O primeiro argumento recebe o índice do qual iniciar a cópia. O segundo argumento recebe o índice do qual interromper a cópia. Ele retorna uma nova matriz com os itens copiados do índice inicial (exclusivo) para o índice final (inclusivo).
Observe, entretanto, que o método de fatia não usa indexação zero. Portanto, o índice do primeiro item da matriz é 1 e não 0:
const numbers = [1,2,3,4,5,7,8];console.log(theArray.slice(1, 4)); // [ 2, 3, 4 ]Conclusão
Espero que tenha gostado de ler este artigo e aprendido algo novo ao mesmo tempo.
Existem muitos métodos de array e string que não mencionei no artigo. Se desejar, reserve um tempo para pesquisar esses métodos.
Se você gostaria de se conectar comigo ou apenas dizer oi, sinta-se à vontade para fazê-lo via Twitter . Também compartilho dicas e recursos interessantes para desenvolvedores. 😉