O Node.JS se beneficiou de seus recursos orientados a eventos e assíncronos e tem sido muito em breve. No entanto, não é possível ser rápido nas redes modernas. Se você planeja usar o Node.js para desenvolver seu próximo aplicativo da Web, faça tudo para tornar seu aplicativo mais rápido e excepcionalmente rápido. Este artigo introduzirá 10 itens e, após o teste, pode melhorar bastante as habilidades da aplicação de nós. Sem mais delongas, vamos dar uma olhada uma a uma.
1. Paralelo
Ao criar um aplicativo da Web, pode ser necessário ligar para a API interna várias vezes para obter vários dados. Por exemplo, suponha na página do painel, você deve executar as seguintes chamadas:
Informações do usuário - getUserProfile ().
Atividade atual - getRecentativity ().
Inscreva -se no conteúdo - getSubscriptions ().
Conteúdo de notificação - getNotifications ().
Para obter essas informações, você deve criar middleware separado para cada método e vincular -as à rota do painel. Mas o problema é que a execução desses métodos é linear e o próximo não começará até que o anterior seja concluído. Uma solução viável é chamá -los em paralelo.
Como você sabe, o Node.js é muito bom em chamar vários métodos em paralelo devido à assíncrono. Não podemos desperdiçar recursos naturais. Os métodos que mencionei acima não têm dependências, para que possamos executá -las em paralelo. Dessa forma, podemos reduzir o número de middleware e aumentar bastante a velocidade.
Podemos usar async.js para lidar com o paralelismo, que é um módulo de nó usado especialmente para treinar JavaScript de forma assíncrona. O código a seguir demonstra como usar async.js para chamar vários métodos em paralelo:
A cópia do código é a seguinte:
function runinparallel () {
async.parallel ([
getUserProfile,
getrecentativity,
getSubscriptions,
Getnotificações
], function (err, resultados) {
// Este retorno de chamada é executado quando todas as funções concluídas
});
}
Se você quiser dar uma olhada mais aprofundada para async.js, vá em sua página do Github.
2. Assíncrono
Por design node.js é um único rosqueado. Com base nisso, o código síncrono bloqueará todo o aplicativo. Por exemplo, a maioria das APIs do sistema de arquivos possui suas versões sincronizadas. O código a seguir demonstra duas operações: Leitura de arquivos síncronos e assíncronos:
A cópia do código é a seguinte:
// assíncrono
fs.readfile ('file.txt', function (err, buffer) {
var content = buffer.toString ();
});
// síncrono
var content = fs.readfilesync ('file.txt'). tostring ();
No entanto, se você executar operações de bloqueio de longo prazo, o encadeamento principal será bloqueado até que essas operações sejam concluídas. Isso reduz bastante o desempenho do seu aplicativo. Portanto, é melhor garantir que seu código use a versão assíncrona da API, pelo menos você deve ser assíncrono no nó de desempenho. Além disso, você deve ter muito cuidado ao escolher módulos de terceiros. Porque quando você tenta remover operações de sincronização do seu código, uma chamada síncrona de uma biblioteca externa desperdiçará todos os seus esforços e reduzirá o desempenho do seu aplicativo.
3. Cache
Se você usar alguns dados que não alteram com frequência, cache -os para melhorar o desempenho. Por exemplo, o código a seguir é um exemplo de obter a postagem mais recente e exibi -lo:
A cópia do código é a seguinte:
var roteter = express.router ();
Router.Route ('/mais recentePosts'). Get (function (req, res) {
Post.getLatest (function (err, postagens) {
if (err) {
lança err;
}
res.render ('Posts', {posts: Posts});
});
});
Se você não postar com frequência, poderá cache a lista de postagens e limpá -los depois de um tempo. Por exemplo, podemos usar o módulo Redis para atingir esse objetivo. Obviamente, você deve instalar o Redis no seu servidor. Em seguida, você pode salvar pares de chave/valor com um cliente chamado Node_redis. O exemplo a seguir mostra como as postagens de cache:
A cópia do código é a seguinte:
var redis = requer ('redis'),
cliente = redis.createclient (null, null, {detect_buffers: true}),
roteador = express.router ();
Router.Route ('/mais recentePosts'). Get (function (req, res) {
client.get ('Posts', function (err, postagens) {
if (postagens) {
return res.render ('Posts', {posts: json.parse (posts)});
}
Post.getLatest (function (err, postagens) {
if (err) {
lança err;
}
client.set ('Posts', JSON.Stringify (Posts));
res.render ('Posts', {posts: Posts});
});
});
});
Veja, vamos verificar o cache Redis primeiro para ver se há alguma postagem. Nesse caso, pegamos essas listas de postagens do cache. Caso contrário, recuperaremos o conteúdo do banco de dados e cache os resultados. Além disso, após um certo período de tempo, podemos limpar o cache Redis para que o conteúdo possa ser atualizado.
4. Compressão GZIP
A ativação da compactação GZIP terá um enorme impacto em seus aplicativos da Web. Quando um navegador compactado GZIP solicita certos recursos, o servidor se comprime antes que a resposta seja retornada ao navegador. Se você não usar o GZIP para comprimir seus recursos estáticos, pode levar mais tempo para o navegador obtê -los.
Em aplicativos expressos, podemos usar o middleware do Express.static () para lidar com conteúdo estático. Além disso, o conteúdo estático pode ser compactado e processado usando o middleware de compressão. Aqui estão os exemplos de uso:
A cópia do código é a seguinte:
var compressão = requer ('compressão');
App.use (compressão ()); // Use a compactação
App.Use (Express.static (Path.Join (__ Dirname, 'Public')));
5. Se possível, renderize com o cliente
Agora, existem estruturas MVC/MVVM super versáteis e poderosas, como AngularJS, Ember, Meteor, etc., e é muito fácil criar um aplicativo de uma página. Basicamente, você só precisa expor uma API e retornar uma resposta JSON ao cliente, sem renderizar a página no servidor. No cliente, você pode organizar os JSOs com estruturas e exibi -las na interface do usuário. Somente o envio de respostas JSON no servidor pode salvar a largura de banda e melhorar o desempenho, porque você não precisa retornar marcas de layout em cada resposta, certo, você só precisa devolver o JSON puro e depois renderizá -las no cliente.
Vamos dar uma olhada no meu tutorial, que é sobre como expor uma API RESTful usando o Express 4. Também escrevi outro tutorial mostrando como combinar essas APIs com o AngularJS.
6. Não guarde muitos dados em sessões
Para aplicativos típicos da página expressa, os dados da sessão são salvos na memória por padrão. Quando você economiza muitos dados na sessão, eles aumentarão significativamente a sobrecarga do servidor. Portanto, você muda para outro método de armazenamento para salvar os dados da sessão ou tenta minimizar a quantidade de dados armazenados na sessão.
Por exemplo, quando os usuários fazem login no seu aplicativo, você pode salvar seus IDs apenas na sessão, em vez de todo o objeto de dados do usuário. Além disso, para as consultas que você pode obter objetos da ID, você deseja usar o MongoDB ou o Redis para armazenar dados de sessão.
7. Otimize a consulta
Suponha que você tenha um blog e queira exibir as postagens mais recentes em sua página inicial. Você pode obter dados através de Mongoose assim:
A cópia do código é a seguinte:
Post.find (). Limite (10) .Exec (função (err, postagens) {
// Envie postagens para o cliente
});
No entanto, o problema é que o método find () de Mongoose consulte todos os campos do objeto, e muitos campos não são necessários na página inicial. Por exemplo, os comentários são respostas para postagens específicas. Não precisamos exibir respostas ao artigo, para que possamos removê -lo ao consultar. Isso, sem dúvida, aumentará a velocidade. A consulta acima pode ser otimizada assim:
A cópia do código é a seguinte:
Post.find (). Limit (10) .Exclude ('Comentários'). Exec (function (err, postagens) {
// Envie postagens para o cliente
});
8. Use o método V8 padrão
Algumas operações em uma coleção, como mapa, redução e foreach, não apóiam necessariamente todos os navegadores. Podemos resolver alguns problemas de compatibilidade do navegador por meio da biblioteca de primeiro plano. Mas para o Node.js, você precisa saber exatamente quais operações o V8 JavaScript Engine do Google suporta. Dessa forma, você pode usar diretamente esses métodos internos para operar a coleção no lado do servidor.
9. Use nginx na frente do nó
O NGINX é um servidor web pequeno e leve que pode reduzir a carga no seu servidor Node.js. Você pode configurar recursos estáticos no Nginx em vez de no nó. Você pode comprimir respostas com o GZIP no Nginx para diminuir todas as respostas. Portanto, se você tem um produto que está em operação, acho que você deve usar o NGINX para melhorar a velocidade de execução.
10. Embalagem JavaScript
Por fim, você também pode melhorar bastante a velocidade do aplicativo de página embalando vários arquivos JS. Quando o navegador encontrar o elemento <Script> na renderização da página, ele será bloqueado e não continuará sendo executado até que o script seja obtido (a menos que a propriedade assíncrona esteja definida). Por exemplo, se a sua página tiver cinco arquivos JavaScript, o navegador emitirá cinco solicitações HTTP separadas para obtê -las. Se esses cinco arquivos forem compactados e embalados em um, o desempenho geral será bastante aprimorado. O mesmo vale para os arquivos CSS. Você pode usar uma ferramenta de compilação como Grunt/Gulp para empacotar seus arquivos de recursos.
para concluir
As 10 dicas acima podem definitivamente melhorar a velocidade dos seus aplicativos da Web. No entanto, eu sei que há espaço para melhorias e otimização. Se você tiver alguma dica para melhorar o desempenho, informe -me na resposta.
Obrigado pela leitura!