Aumente sua produtividade com Node.js utilizando Arrow Functions

E aí pessoal! Belezura?

Hoje vamos falar sobre Arrow Functions, e como elas podem nos ajudar na produtividade quando trabalhamos com Node.js. Bora!

Tempos atrás, escrevi um post falando sobre expressões lambda e arrow functions, esse aqui. Lá, descrevi sobre um pacote chamado devbox-linq que foi inspirado no C# e tem várias funcionalidades que facilitam MUITO o desenvolvimento no nosso dia-a-dia. Volto novamente para falar desse pacote que passou por algumas mudanças e refatorações pra facilitar ainda mais!

Deixo aqui meus parabéns e agradecimentos ao Gustavo e o Lenon que passaram um bom tempo para refatorar e deixar esse pacote cada dia melhor 😀

O que são Arrow Functions mesmo?

As Arrow Functions vieram com o EcmaScript 6. E são basicamente uma “nova” forma de se trabalhar com funções utilizando o operador =>Pra ser bem sucinto e ir direto ao assunto, vejam um exemplo de uma função do jeito “antigo”:

var soma = function (a, b) {
return a + b;
}

view raw
soma.js
hosted with ❤ by GitHub

E agora trabalhando com arrow functions:

var soma = (a, b) => {
return a + b;
}

view raw
somaarrowfunction.js
hosted with ❤ by GitHub

Ainda podemos simplificar mais ainda assim:

var soma = (a, b) => a + b;

Certo, agora todo mundo sabe o que são arrow functions, né? Então vamos para o próximo passo!

Como as arrow functions podem ajudar na produtividade?

Quando comecei a fazer projetos com Node.js, estava muito acostumado com os projetos em C#, e confesso que senti muita falta de uma biblioteca chamada System.Linq, pois com ela conseguimos filtrar e manipular listas. Um exemplo básico, é somar todos os elementos de um array. Com C# fica mais ou menos assim:

var lstInt = new List<int> {1, 2, 3, 4, 5};
var soma = lstInt.Sum();

view raw
Soma.cs
hosted with ❤ by GitHub

Outro exemplo legal para falarmos do C#, é filtrar uma lista de clientes, onde queremos apenas clientes do sexo masculino com mais de 20 anos, que ficaria mais ou menos assim:

public IEnumerable<Cliente> ClientesMasculinosComMaisDeVinteAnos(IEnumerable<Cliente> clientes)
{
//Reparem no uso da expressão Lambda
return clientes.Where(c => c.Idade > 20 && c.Sexo == "Masculino");
}

view raw
FiltroLambda.cs
hosted with ❤ by GitHub

Pra fazer com JavaScript da maneira convencional, precisaríamos fazer de algumas maneiras… Primeiro vamos ver a forma mais convencional possível:

var lstInt = [1, 2, 3, 4, 5];
var soma = 0;
for(var i = 0; i < lstInt.length; i++) {
soma = soma + lstInt[i];
}
console.log(soma); //15

view raw
somaarray.js
hosted with ❤ by GitHub

Existe uma maneira bem melhor, utilizando o “reduce“, que fica mais ou menos assim:

var lstInt = [1, 2, 3, 4, 5];
var soma = lstInt.reduce(function(total, proximo) {
return total + proximo;
});
console.log(soma); //15

view raw
somareduce.js
hosted with ❤ by GitHub

Agora vamos adicionar as arrow functions junto ao reduce:

var lstInt = [1, 2, 3, 4, 5];
var somar = (a, b) => a + b;
var soma = lstInt.reduce(somar);
console.log(soma); //15

view raw
somaarrow.js
hosted with ❤ by GitHub

Notem, que em cada uma das abordagens escrevemos cada vez menos código. Porém, com o uso do devbox-linq o negócio fica lindo! Vejam como fica o exemplo da soma:

var lstInt = [1, 2, 3, 4, 5];
var soma = lstInt.sum(); //15

view raw
somadevbox.js
hosted with ❤ by GitHub

Não precisamos escrever quase NADA 🙂

Vejam um outro exemplo onde somamos elementos de um objeto:

var produtos = [
{ nome: 'Café', preco: 10 },
{ nome: 'Açucar', preco: 5 }
];
var somaPreco = produtos.sum(x => x.preco); //15

view raw
somaobjeto.js
hosted with ❤ by GitHub

Agora vejam o exemplo de filtro de clientes:

var clientes = [
{ nome: 'Zé', sexo: 'Masculino', idade: 25 },
{ nome: 'Tonho', sexo: 'Masculino', idade: 18 },
{ nome: 'Maria', sexo: 'Feminino', idade: 25 }
];
var clientesMasculinosMaioresDe20Anos = clientes.where(x => x.sexo == 'Masculino' && idade > 20);
// [ { nome: 'Zé', sexo: 'Masculino', idade: 25 } ]

view raw
filtrocliente.js
hosted with ❤ by GitHub

O que mais podemos fazer?

Temos várias possibilidades, vejam no exemplo abaixo um pouco do que podemos fazer:

require('devbox-linq');
var listaDeCoisas = [
{ id: 1, nome: 'Coisa 01', tipo: 'A' },
{ id: 2, nome: 'Coisa 02', tipo: 'A' },
{ id: 3, nome: 'Coisa 03', tipo: 'B' },
{ id: 4, nome: 'Coisa 04', tipo: 'B' },
{ id: 4, nome: 'Coisa 04', tipo: 'B' },
{ id: 5, nome: 'Coisa 05', tipo: 'C' }
];
var somenteTipoC = listaDeCoisas.where(x => x.tipo == 'C');
// [ { id: 5, nome: 'Coisa 05', tipo: 'C' } ]
var primeiroTipoA = listaDeCoisas.first(x => x.tipo == 'A');
// { id: 1, nome: 'Coisa 01', tipo: 'A' }
var existeAlgumTipoB = listaDeCoisas.any(x => x.tipo == 'B');
// true
var quantidadeCoisasTipoA = listaDeCoisas.count(x => x.tipo == 'A');
// 2
var coisasSemRepetir = listaDeCoisas.distinct();
/*
{ id: 1, nome: 'Coisa 01', tipo: 'A' },
{ id: 2, nome: 'Coisa 02', tipo: 'A' },
{ id: 3, nome: 'Coisa 03', tipo: 'B' },
{ id: 4, nome: 'Coisa 04', tipo: 'B' },
{ id: 5, nome: 'Coisa 05', tipo: 'C' }
*/
var coisasAgrupadas = listaDeCoisas.groupBy(x => x.tipo);
/*
[
[
{ id: 1, nome: 'Coisa 01', tipo: 'A' },
{ id: 2, nome: 'Coisa 02', tipo: 'A' }
],
[
{ id: 3, nome: 'Coisa 03', tipo: 'B' },
{ id: 4, nome: 'Coisa 04', tipo: 'B' },
{ id: 4, nome: 'Coisa 04', tipo: 'B' }
],
[
{ id: 5, nome: 'Coisa 05', tipo: 'C' }
]
]
*/
console.log(coisasAgrupadas[0].key) // 'A'
var minimo = listaDeCoisas.min(x => x.id)
// 1

view raw
exemploslinq.js
hosted with ❤ by GitHub

Além disso tem várias outras funcionalidades, como “orderBy“, “select“, “skip“, “take“, dentre tantas outras.

Como eu uso?

Para utilizar é só instalar o pacote via npm dessa maneira:

npm install devbox-linq

A documentação está bem legal, e você pode encontrar ela aqui: https://www.npmjs.com/package/devbox-linq

Caso não tenha alguma funcionalidade que você precisa, é só fazer um fork e mandar um pull request que estamos de braços abertos 🙂

O link do Github é esse aqui: https://github.com/GustavoMaritan/LinqJs

Por hoje é só, qualquer dúvida ou sugestão, estou à disposição! Até mais 😀

2 thoughts on “Aumente sua produtividade com Node.js utilizando Arrow Functions

  1. igor de souza morais 17/04/2018 / 20:42

    Muito bom parabens

    Gostar

  2. Julio Bandeira 17/05/2018 / 00:00

    Topper demais, mão na roda

    Gostar

Deixe uma Resposta

Preencha os seus detalhes abaixo ou clique num ícone para iniciar sessão:

Logótipo da WordPress.com

Está a comentar usando a sua conta WordPress.com Terminar Sessão /  Alterar )

Google photo

Está a comentar usando a sua conta Google Terminar Sessão /  Alterar )

Imagem do Twitter

Está a comentar usando a sua conta Twitter Terminar Sessão /  Alterar )

Facebook photo

Está a comentar usando a sua conta Facebook Terminar Sessão /  Alterar )

Connecting to %s