Tempo de leitura: 6 minutos
Todos nós já ouvimos muito falar sobre a rápida expansão do JavaScript nos últimos anos. Além disso, o JavaScript tem sido a linguagem número 1 utilizada no GitHub, incrível hein?!
E alguns até dizem que o JavaScript é a linguagem número 1 no mundo; A linguagem da web, e o início de carreira de muitos programadores.
E com certeza uma das maiores razões para a rápida expansão do JavaScript entre os programadores tem sido a enorme influência do Node.js.
Aqui não vamos precisar explicar o que é Node.js pois já fizemos isso de forma detalhada AQUI neste Artigo.
Portanto fique agora com estas dicas para criar aplicações poderosas com Node.Js
O que vamos aprender neste artigo?
// 1. Familiarize-se com import e import()
// 2. Adote o uso de microservices
// 4. Use a renderização Client Side (lado do cliente) quando possível
// 6. Comece a usar async – await
// 7. Não use Node.js para renderizar assets
1. Familiarize-se com import e import()
ES modules são bastante usados com transpilers ou com a lib @std/esm. Eles são suportados nativamente desde o Node.js 8.5 com a flag --experimental-modules, porém ainda existe um longo caminho até se tornar estável para rodar em produção.
Minha sugestão é que você aprenda as bases atuais e continue acompanhando o progresso em 2019. Você pode encontrar um tutorial de ES modules simples com o Node.js no blog do Dr. Axel Rauschmayer.
// --util.js--
export default function sum(...numbers) {
return numbers.reduce((total, value) => total + value);
}
// –test.js–
import sum from “./util”;
console.log(“== Using sum method from file ==”);
console.log(“SUM =”, sum(1, 2, 3)); // 6
// try import()
button.addEventListener(“click”, event => {
import(“./modal.js”)
.then(modal => {
modal.open();
})
.catch(error => {
/* Error handling */
});
});
2. Adote o uso de microservices
Se por acaso você tiver algum problema na implantação de projetos de grande escala, acredito que é a hora exata de optar pela arquitetura dos microservices.
Aprenda sobre as duas ferramentas abaixo para se manter atualizado na cena dos microservices.
Kubernetes é um sistema de código aberto para automatizar a implantação, o dimensionamento e o gerenciamento de aplicativos em contêiner.
Docker é uma tecnologia de software que fornece contêineres, que envolvem um software em um sistema de arquivos completo que contém tudo o que ele precisa para executar: código, tempo de execução, ferramentas do sistema e bibliotecas do sistema.
Mas antes de você se aprofundar em containers e orchestration, vá melhorando seu código já existente.
Siga o método da aplicação de 12 fatores e você terá um tempo bem maior para desenvolver containers e deploy de seus serviços.
3. Use o cache
Caso você esteja buscando alguns dados que não mudam frequentemente, você pode armazená-los em cache para melhorar o desempenho.
Por exemplo, pegue o seguinte snippet que faz uma busca pelas postagens mais recentes para serem exibidas em uma visualização:
var router = express.Router();
router.route('/latestPosts').get(function(req, res) {
Post.getLatest(function(err, posts) {
if (err) {
throw err;
}
res.render('posts', { posts: posts });
});
});Se você não faz postagens no seu blog com frequência, poderá armazenar em cache postsmatriz e limpar o cache após um intervalo.
Por exemplo, podemos usar o redismódulo para conseguir isso. Para isso você precisa ter o Redis instalado no seu servidor. Então você pode usar um cliente chamado node_redis para armazenar pares chave / valor.
Veja no snippet a seguir como podemos armazenar as postagens em cache:
var redis = require('redis'),
client = redis.createClient(null, null, { detect_buffers: true }),
router = express.Router();
router.route('/latestPosts').get(function(req,res){
client.get('posts', function (err, posts) {
if (posts) {
return res.render('posts', { posts: JSON.parse(posts) });
}
Post.getLatest(function(err, posts) {
if (err) {
throw err;
}
client.set('posts', JSON.stringify(posts));
res.render('posts', { posts: posts });
});
});
});Primeiro fazemos a verificação para ver se as mensagens existem no cache do Redis. Se assim for, nós entregamos o postsarray do cache.
Caso contrário, nós recuperamos o conteúdo do banco de dados e logo em seguida armazenamos em cache.
Além do mais, após um intervalo, podemos fazer uma limpeza no cache do Redis para que o novo conteúdo possa ser buscado.
4. Use a renderização Cliente Side (lado do cliente) quando possível
Com o surgimento de muitos frameworks poderosos MVC / MVVM do lado do cliente, como AngularJS, Ember, Meteor e outros, ficou muito mais fácil desenvolver aplicativos de página única (One Page).
Basicamente, em vez de renderizar no lado do servidor, você apenas expõe APIs que enviam respostas JSON ao cliente.
No lado do cliente, você pode utilizar um framework para consumir o JSON e exibir na interface do usuário.
O envio de JSON do servidor pode economizar largura de banda e, assim, melhorar a velocidade, pois você não envia a marcação de layout a cada solicitação. Em vez disso, você simplesmente envia JSON simples, que é então renderizado no lado do cliente.
5. Otimize suas consultas
Vamos supor que você possua um blog que mostre postagens mais recentes na página inicial. Você pode escrever algo assim para buscar dados usando o Mongoose:
Post.find().limit(10).exec(function(err, posts) {
//send posts to client
});Mas o problema é que a find() no Mongoose busca todos os campos de um objeto e pode haver vários campos no Postobjeto que não são necessários na página inicial.
Por exemplo, comments é um desses campos que contém uma série de comentários para um post específico.
Como não estamos mostrando os comentários, podemos excluí-lo durante a busca. Isso irá melhorar a velocidade definitivamente. Podemos otimizar a consulta acima com algo desse tipo:
Post.find().limit(10).exclude('comments').exec(function(err, posts) {
//send posts to client
});
6. Comece a usar async – await
Async — await aterrissou no Node 8 e causou um boom.
Isso modificou a forma como nós lidamos com os eventos assíncronos e simplificou as incompreensíveis bases de código que existiam até então.
Atualizando seu conhecimento sobre a programação assíncrona, nossa postagem sobre Promises no JavaScript também pode ajudar.
const axios = require("axios");
async function requestUserData() {
try {
const userPromise = axios(“https://randomuser.me/api/”);
const namePromise = axios(“https://uinames.com/api/”);
/* Aguardando as duas promises retornarem
* para armazenar o resultado em nossas próprias variáveis
*/
const [randomUser, randomName] = await Promise.all([
userPromise,
namePromise
]);
console.log(randomUser.data, randomName.data);
} catch (e) {
console.error(e); // error
}
}
7. Não use Node.js para renderizar assets
Uma dica de performance crítica seria renderizar seus assets estáticos, como CSS e imagens, em um servidor padrão como Nginx.
Ao fazer com que o Nginx sirva seu conteúdo estático, você vai ter uma redução significativa no carregamento na sua instância Node.js e no processo de melhorar a performance.
Conclusão de Dicas para Criar aplicações com Node.Js
Então, aqui vimos dicas para desenvolver aplicações com Node.js de forma a trazer mais performance para suas aplicações. O que você achou dessas dicas? já utiliza alguma? tem alguma sugestão? Fala conosco nos comentários!
