Funções Puras

Falae gente, tudo certinho!

Hoje vamos continuar nossa série de programação funcional com o conceito de Funções Puras.

Diferente das funções impuras, nossas funções tem duas características fundamentais:

. Mesmo retorno para a mesma entrada .

As funções puras sempre retornam o mesmo valor para a mesma entrada, pois não dependem de variáveis externas ou globais. Quando escrevemos a seguinte função:

A função resultado depende de uma variável externa, dessa forma caso o valor mude o resultado pode ser diferente para um mesmo valor de a. Para que a função seja pura, ela precisa ser escrita da seguinte forma:

Dessa forma ela depende apenas de seu conteúdo para entregar o resultado.

. Não causam efeitos colaterais .

Observe a função abaixo:

A função utiliza de uma variável externa e incrementa seu valor dentro do laço while. Porém se depurarmos seu valor após este passo verificamos que seu valor inicial de agora está 6, ou seja, um efeito colateral. Caso utilizemos essa variável em outra parte precisamos nos certificar do seu valor.

Caso a função fosse pura, ela não modificaria nada além de seu escopo.

Quais as vantagens de utilizar as funções puras?

  • Como não dependem de dados mutáveis, estados ou dados fora de seu escopo são mais fácies de processamento, teste e depuração;
  • Podemos clonar essas funções sem nos preocuparmos se irão funcionar;

Espero que tenham gostado.

fui!

in N Of

Salve rapaziada, tudo certinho!

Fiquei um tempo sem postar nada, pois estou envolvido em dois projetos de aplicativos em react-native, que futuramente pretendo fazer umas postagens também xD.

Vamos tratar hoje de um novo recurso, novo assim rsrsrsrsrs, que surgiu nas últimas versões do ECMAScript (nome padronizado do Javascript ), o FOR OF.

Aprendemos nas primeiras aulas de toda linguagem que temos as estruturas de repetição, os laços, normalmente while(), do while() e o for(). Entretanto algumas linguagens contam com o for in que percorre todas as chaves de um Array, por exemplo e assim conseguimos obter seus valores, como por exemplo:

Temos uma Array chamada assuntosJS com 3 elementos e abaixo passamos nosso for in que retorna as chaves:

Porém, na maioria das vezes precisamos dos valores de um elemento, então precisamos mudar nosso for in, para exibir esses valores:

Agora porém contamos com o FOR OF, que percorre os elementos e não as chaves. Notem a baixo que a declaração é bem parecida, declaramos uma variável que vai percorrer os elementos e colocamos o OF:

Obtemos o mesmo resultado, mas agora sem se preocupar com a chave:

Lembrando que temos outras formas de passar por uma Array disponíveis também, segue abaixo esses outros métodos em postagens aqui do blog:

ForEach() – https://devzanini.ml/index.php/2021/06/23/paracada/

Map() – https://devzanini.ml/index.php/2021/06/24/for-com-proposito/

Filter() – https://devzanini.ml/index.php/2021/06/25/forif/

Reduce() – https://devzanini.ml/index.php/2021/06/25/reduza-p/

Espero que tenham gostado dessa postagem rápida.

Nos vemos no próximo post!

Console.log(‘Fui…’)

Prototype

Salve rapaziada, tudo certinho!

Vamos um falar um pouco sobre o prototype dentro das Arrays!

Em linguagens orientadas à objeto, quando precisamos implementar ou sobrescrever métodos de uma classe temos a notação @override.

Com ela conseguimos fazer isso, sobrescrever, por exemplo métodos da classe Pai a qual estamos trabalhando.

Vou mostrar um exemplo em dart, quando precisamos alterar um método, sem que precisemos alterar a classe pai,

Neste exemplo, temos uma classe chamada Vehicle que tem implementada um método chamado printDetails().

Abaixo temos a classe Car, filha da classe Vehicle, notem a palavra chave extends, e em seu escopo a notação @overrdide. Logo em seguida temos novamente o método printDetails(), só que agora sobrescrito por uma implementação diferente.

Isso garante que a classe filha herde toda a estrutura da classe pai, e se precisamos sobrescrever algum método, não alteramos nada a classe pai, garantindo sua integridade, sem falar que se precisar criar outra classe filha, só tenho alteração do método na classe Car.

Certo, mas posso fazer isso em funções????

Sim! No JS podemos, graças ao super e poderoso Prototype()!

Mas o JS não trabalho necessariamente com classes, até posso, mas são as funções que reinam…

Tudo no JS é classe… Como Assim???

Mesmo que eu defina uma classe, se exibir o tipo dela, tenho como retorno uma função:


WTF!

No JS toda função tem uma estrutura de construção. Se assemelha a uma classe, onde estão todos os métodos e atributos. A essa coleção chamados prototype. Então podemos utilizar esse “método”, coloquei entre parênteses pois tudo é função rsrsrs, e sobrescrever um método ou mesmo implementar os nossos.

Como estamos falando de Arrays. Vou implementar um método de impressão:

  • Através do prototype, eu criei um novo método para a Array do JS, onde implementei uma mensagem que é uma função (e ela pode receber dados como parâmetros);
  • Crio uma Array de alunos;
  • Com a Array alunos, chamo o método implementado e tenho o resultado no console.

Através dessa funcionalidade da linguagens conseguimos implementar nossos métodos, seja para Array ou outras APIs presentes no JS.

Espero que tenham gostado.

Console.log(‘Fui…’)

Reduza !? ;P

Salve rapaziada, tudo certinho!

Para encerrar esse série de funções que trabalham em prol da Array, vamos falar de reduce().

Voltemos a nossa Array em C. Criamos uma variável para armazenar o total, depois um for() para percorrer a Array, dentro colocamos que devemos armazenar à variável, ela mesma acrescida do elemento atual passado pelo laço.

Velho TurboC, deu até vontade de abrir ele novamente… Ainda bem que vontade é um negócio que dá e vai embora 😀

Quando precisamos passar pelos elementos de uma Array e ir acumulando valores, temos a nossa disposição em JS e em outras linguagens a função reduce().

Essa função trabalha da seguinte forma. Quando aplicada a uma Array, passamos uma callback (função de retorno) com dois parâmetros, o acumulador e o atual.

Inicialmente essa função vai colocar o primeiro elemento que é o índice 0 (zero) da Array na variável acumulador, e o segundo elemento que é índice 1 na variável atual.

Ao percorrer a Array, dependendo de sua callback, ela vai pegar o resultado de sua função e colocar na variável acumulador, e o terceiro elemento que é índice 2 para a variável atual e assim vai, até o último elemento.

Deixa eu demonstrar com um exemplo. Considerem a seguinte Array:

E desejamos somar todas as notas dessa Array.

Primeiro precisamos fazer uma Array só de notas, para depois somar as notas. Então vamos utilizar a função map() (clique aqui para conhecer), e passar uma callback que nos retorne apena a nota de cada aluno. E para ter certeza vamos imprimir no console o resultado:

Agora que temos apenas as notas, vamos criar uma callback que retorne a somatória das notas, para que possamos aplicar a função reduce():

Então eu declarei uma constante chamada totalNotas e associei uma arrow function passando dois parâmetros, acumulador, que receberá a somatória das notas e atual, que receberá o elemento atual da Array. E retorno sempre a somatória desses valores, ou seja, ao aplicar essa callback à reduce() vai acontecer o seguinte:

1 – No primeiro elemento, teremos que o acumulador será 7.3, o primeiro elemento da Array, e o atual será 9.2, o segundo elemento;
2 – Ao chegar no segundo elemento, a função irá somar o valor do acumulador, 7.3 + 9.2 (16,5) e colocar o resultado no acumulador e associará 9.8, o terceiro elemento, à variável atual;
3 – Ao chegar no terceiro, vai somar o valor de acumulador 16,5 + 9.8 (26,3) e associará à variável acumulador. Colocar 8,7 o quarto elemento, na variável atual;
4 – No último elemento, somar o acumulador 26,3 à variável atual 8.7 retornando o resultado 35.

Vou acrescentar um console.log() à cada passagem da reduce() para exemplificar o passo-a-passo acima:

Espero que tenham gostado e nos vemos no próximo post!

Ah sim, como esse é o ultimo post de nossa série sobre Arrays, abaixo tem os links dos posts sobre as funções forEach(), map() e filter() 😉

Console.log(“Fui…”)

Forif !

Salve rapaziada, tudo certinho!

Vamos falar hoje sobre a função filter() usada em Arrays.

Lembro da minha época de C, quando era preciso percorrer os elementos de uma Array para procurar determinados valores…

Era um for() para percorrer os elementos, depois um if() para o critério, sem falar que era preciso associar os elementos a uma nova Array.

Não estou falando mal de C, pelo contrário, foi a primeira linguagem em que “codei”. A lógica de programação era em uma matéria chamada LEA, lembro até hoje rsrsrsrs. LEA (Lógica Estruturada Aplicada), que era ministrada com o saudoso COBOL IBM 95…

Voltando à realidade rsrsrsrs…

Em JS e na maioria das linguagens de hoje, temos uma função chamada filter() que percorre os elementos de uma Array aplicando um filtro que definimos por uma callback. E no final nos devolve uma array com os elementos resultantes desse filtro.

Vamos supor à seguinte array de objetos:

E quero trazer apenas os objetos em que o preço é menor que 2500.

1 – Então crio uma constante produtos2500 que receberá meu novo Array;
2 – Associo a Array produtos e aplico o filter();
3 – Passo minha callback, onde o critério é “retornar os elementos onde o preço é menor que 2500”;

E por fim exibo o resultado:

Assim como a função map() (clique aqui para saber mais), podemos encadear vários filter() para trazer o resultado desejado:

1 – Temos a Array produtos que contém os objetos como elementos;
2 – Crio duas constantes que armazenam duas funções. A primeira, frágil, recebe como parâmetro o produto e retorna “os produtos que são frágeis”. A segunda, menor500, recebe como parâmetro produto e retorna “os produtos com preço menor que 500”;
3 – À constante resultado, associo a Array produtos aplicando dois filter(), dentro de cada um coloco as funções de callback, fragil e menor500;
4 – Exibo no console essa constante resultado:

Lembrando que diferente da função map(), que sempre retorna uma Array de mesmo tamanho, a função filter() pode retornar com um tamanho menor, dependendo do critério utilizado. Ela também não altera a Array de origem.

Espero que tenham gostado. Nos vemos no próximo post sobre a função reduce()

Console.log(“Fui…”)

For com propósito

Salve rapaziada, tudo certinho!

Continuando com o tema de Arrays, hoje vamos falar da função map().

Essa função quando aplicada retorna uma outra array modificada do mesmo tamanho, porém sem qualquer alteração da original.

Da mesma forma que a função forEach() (clique aqui para conhecer), devemos passar uma callback(função de retorno), que será aplicada em todos os elementos da Array.

Vamos tomar como exemplo a constante abaixo:

E queremos o dobro de cada elemento.

Então definimos uma variável. Aplicamos a função map() colocando dentro nossa callback e que terá como resultado uma array com o dobro de cada elemento:

e termos e seguinte resultado:

Vamos por partes.

1 – Definimos nossa variável:

2 – Associamos a array que iremos aplicar a função:

3 – Aplicamos a função map() e dentro dela colocamos nossa callback. Nossa callback é uma função anônima que recebe como parâmetro a variável elemento, que é retornada em seguida multiplicada por 2:

Somente para entender melhor, podemos criar nossa callback antes, e depois aplicar diretamente a função:

As possibilidades são grandes com a função map. Podemos por exemplo encadear um map() atrás do outro para produzir um resultado desejado:

1 – Definimos uma Array com 5 elementos;
2 – Criamos 3 constantes e em cada uma delas associamos uma função que será utilizada como callback. São elas dobro, soma20 e formataReal;
3 – À variável resultado associamos a array nums e aplicamos três map(), cada uma com sua callback;

Teremos como resultado:

Reforçando, a função map() quando aplicada à uma Array precisa de uma callback, seja anônima, nomeada, arrow, que será aplicada a cada elemento e retornará uma nova array, sem modificar a original:

Espero que tenham gostado, nos próximos posts vamos tratar das funções filter() e reduce() para irmos a programação funcional.

Nos vemos lá!

Console.log(“Fui…”)

ParaCada?

Salve rapaziada, tudo bem com vocês.

Hoje vamos falar um pouco sobre uma das funções que facilitam muito a vida de todo desenvolvedor JS e também de outras linguagem de programação quando falamos de Array, se trata da forEach().

Lembro quando aprendi C, lá em 2003 como era divertido percorrer um Array com o for, ainda mais quando tínhamos as Arrays Bi-Dimensionais e quando fui para o C++ as Multi-Dimensionais 🙁

Voltando a realidade, existem forma de percorrer uma determinada Array, por exemplo,

Utilizando o for por exemplo:

E temos no console a saída:

Temos que saber o tamanho da Array, além de declarar variável para percorrer o índice, isso quando por descuido não criamos um looping infinito e travamos a aplicação.

Mas podemos utilizar o forEach() para fazer este mesmo processo. Ele irá percorrer todos os elementos da Array aplicando sua função neles:

Onde teremos o mesmo resultado, dessa vez sem declara variável para controlar o índice ou mesmo nos preocuparmos com o tamanho da Array:

Como funciona o forEach()

Esta função sempre precisa de uma callback (função de retorno) como parâmetro:

Podemos passar uma função anônima como do exemplo acima, uma arrow function ou uma função declarada.

Para sua função de callback, ela sempre vai enviar três parâmetros,

. Elemento (o elemento da array);
. Índice (índice correspondente do elemento);
. Array (array que correspondente da chamada)*;

Como em Javascript os parâmetros das funções não não obrigatórios, não precisamos usar todos, por exemplo, se quiser usar apenas o Elemento da Array:

e teremos o resultado:

Lembrando que o forEach() sempre passa os parâmetros nessa ordem, ou seja se quiser usar apenas o índice, precisamos passar também o elemento antes, mesmo que ele não seja usado:

Espero que tenham gostado.

Nos vemos no próximo post.

Console.log(“Fui…”)