10 conseils pour optimiser la vitesse de votre application Web Node.js_node.js

Node.js est déjà rapide grâce à sa nature événementielle et asynchrone. Cependant, dans les réseaux modernes, il ne suffit pas d’être rapide. Si vous envisagez d'utiliser Node.js pour développer votre prochaine application Web, vous devez faire tout ce qu'il faut pour rendre votre application plus rapide, incroyablement rapide. Cet article présentera 10 astuces testées qui peuvent grandement améliorer les applications Node. Sans plus attendre, examinons-les un par un.

1. Parallèle

Lors de la création d'une application Web, vous devrez peut-être appeler l'API interne plusieurs fois pour obtenir diverses données. Par exemple, supposons que sur la page Tableau de bord, vous souhaitiez exécuter les appels suivants :

Informations utilisateur -getUserProfile().

Activité actuelle -getRecentActivity().

Contenu de l'abonnement -getSubscriptions().

Contenu de la notification -getNotifications().

Pour obtenir ces informations, vous devez créer un middleware distinct pour chaque méthode, puis les lier à la route du tableau de bord. Mais le problème est que l’exécution de ces méthodes est linéaire, et la suivante ne démarrera qu’à la fin de la précédente. Une solution possible est de les appeler en parallèle.

Comme vous le savez, Node.js est très efficace pour appeler plusieurs méthodes en parallèle en raison de l'asynchronicité. Nous ne pouvons pas gaspiller nos ressources. Les méthodes que j'ai mentionnées ci-dessus n'ont aucune dépendance, nous pouvons donc les exécuter en parallèle. De cette façon, nous pouvons réduire la quantité de middleware et augmenter considérablement la vitesse.

Nous pouvons utiliser async.js pour gérer le parallélisme, qui est un module Node spécialement utilisé pour régler JavaScript de manière asynchrone. Le code suivant montre comment utiliser async.js pour appeler plusieurs méthodes en parallèle :

Copier le code Le code est le suivant :

fonction runInParallel() {
async.parallel([
Obtenir un profil utilisateur,
GetRecentActivity,
Obtenez des abonnements,
Recevoir des notifications
], fonction (erreur, résultats) {
//Ce rappel s'exécute lorsque toutes les fonctions sont terminées
});
>

Si vous souhaitez en savoir plus sur async.js, veuillez visiter sa page GitHub.

2. Asynchrone

Node.js est de par sa conception monothread. Sur cette base, le code synchrone peut obstruer l'ensemble de l'application. Par exemple, la plupart des API de système de fichiers ont leurs versions synchrones. Le code suivant illustre les opérations synchrones et asynchrones de lecture de fichiers :

Copier le code Le code est le suivant :

// Asynchrone
fs.readFile('file.txt', function(err, buffer) {
var content = buffer.toString();
});

// Synchrone
var content = fs.readFileSync('file.txt').toString();

Mais si vous effectuez des opérations de blocage à long terme, le thread principal sera bloqué jusqu'à ce que ces opérations soient terminées. Cela réduit considérablement les performances de votre application. Par conséquent, il est préférable de vous assurer que vous utilisez la version asynchrone de l'API dans votre code. Vous devez au moins être asynchrone dans le nœud de performances. De plus, vous devez être prudent lorsque vous choisissez des modules tiers. Car lorsque vous essayez d’éliminer les opérations de synchronisation de votre code, un appel synchrone depuis une bibliothèque externe annulera tous vos efforts et réduira les performances de votre application.

3. Mise en cache

Si vous utilisez des données qui ne changent pas fréquemment, vous devez les mettre en cache pour améliorer les performances. Par exemple, le code suivant est un exemple d'obtention des dernières publications et de leur affichage :

Copier le code Le code est le suivant :

var routeur = express.Router();

router.route('/latestPosts').get(function(req, res) {
Post.getLatest(function(err, posts) {
Si (erreur) {
           lancer une erreur ;
>

res.render('posts', { posts: posts });
});
});

Si vous ne publiez pas souvent, vous pouvez mettre en cache la liste des publications et les effacer après un certain temps. Par exemple, nous pouvons utiliser le module Redis pour atteindre cet objectif. Bien entendu, vous devez avoir Redis installé sur votre serveur. Vous pouvez ensuite utiliser un client appelé node_redis pour enregistrer les paires clé/valeur. L'exemple suivant montre comment nous mettons en cache les publications :

Copier le code Le code est le suivant :

var redis = require('redis'),
Client = redis.createClient(null, null, { detect_buffers: true }),
Routeur = express.Router();

router.route('/latestPosts').get(function(req,res){
client.get('posts', function (erreur, posts) {
Si (postes) {
Renvoie res.render('posts', { posts: JSON.parse(posts) });
>

Post.getLatest(function(err, posts) {
Si (erreur) {
          lancer une erreur ;
>

client.set('posts', JSON.stringify(posts));
res.render('posts', { posts: posts });
});
});
});

Vous voyez, nous vérifions d'abord le cache Redis pour voir s'il y a une publication. Si tel est le cas, nous récupérons la liste des publications du cache. Sinon, nous récupérons le contenu de la base de données et mettons en cache les résultats. De plus, après un certain temps, nous pouvons vider le cache Redis afin que le contenu puisse être mis à jour.

4. compression gzip

L'activation de la compression gzip peut avoir un impact énorme sur votre application Web. Lorsqu'un navigateur compressé par gzip demande une ressource, le serveur compresse la réponse avant de la renvoyer au navigateur. Si vous ne compressez pas vos ressources statiques, le navigateur peut mettre plus de temps à les obtenir.

Dans les applications Express, nous pouvons utiliser le middleware express.static() intégré pour gérer le contenu statique. De plus, le contenu statique peut être compressé et traité à l'aide d'un middleware de compression. Voici un exemple d'utilisation :

Copier le code Le code est le suivant :

var compression = require('compression');

app.use(compression()); //utiliser la compression
app.use(express.static(path.join(__dirname, 'public')));

5. Si possible, utilisez le rendu côté client

De nos jours, il existe de nombreux frameworks MVC/MVVM côté client polyvalents et puissants, tels que AngularJS, Ember, Meteor, etc., ce qui rend très facile la création d'une application d'une seule page. Fondamentalement, vous exposez simplement une API et renvoyez une réponse JSON au client sans afficher la page côté serveur. Côté client, vous pouvez utiliser des frames pour organiser JSON et les afficher sur l'interface utilisateur. L'envoi uniquement de réponses JSON sur le serveur permet d'économiser de la bande passante et d'améliorer les performances, car vous n'avez pas besoin de renvoyer le balisage de mise en page dans chaque réponse, n'est-ce pas ? Il vous suffit de renvoyer du JSON pur, puis de les restituer sur le client.

Consultez mon tutoriel sur la façon d'exposer une API RESTful avec Express 4. J'ai également écrit un autre tutoriel qui montre comment combiner ces API avec AngularJS.

6. Ne stockez pas trop de données dans les sessions

Dans une application de page Express typique, les données de session sont stockées en mémoire par défaut. Lorsque vous enregistrez trop de données dans la session, la surcharge du serveur augmente considérablement. Ainsi, soit vous passez à une autre méthode de stockage pour enregistrer les données de session, soit vous essayez de réduire la quantité de données stockées dans la session.

Par exemple, lorsqu'un utilisateur se connecte à votre application, vous pouvez enregistrer uniquement son identifiant dans la session au lieu de l'intégralité de l'objet de données utilisateur. De plus, pour les requêtes où vous pouvez obtenir l'objet par identifiant, vous souhaiterez peut-être utiliser MongoDB ou Redis pour stocker les données de session.

7. Optimiser la requête

Supposons que vous ayez un blog et que vous souhaitiez afficher les derniers articles sur la page d'accueil. Vous pouvez récupérer des données via Mongoose comme ceci :

Copier le code Le code est le suivant :

Post.find().limit(10).exec(function(err, posts) {
//envoyer des messages au client
});

Mais le problème est que la méthode find() de Mongoose interrogera tous les champs de l'objet et que de nombreux champs ne sont pas obligatoires sur la page d'accueil. Par exemple, commentsis stocke les réponses à une publication spécifique. Nous n'avons pas besoin d'afficher les réponses aux articles, nous pouvons donc les exclure lors de la requête. Cela augmentera certainement la vitesse. Vous pouvez optimiser la requête ci-dessus comme ceci :

Copier le code Le code est le suivant :

Post.find().limit(10).exclude('comments').exec(function(err, posts) {
//envoyer des messages au client
});

8. Utilisez la méthode V8 standard

Certaines opérations sur les collections, telles que map, réduire et forEach, peuvent ne pas être prises en charge dans tous les navigateurs. Nous pouvons résoudre certains problèmes de compatibilité du navigateur grâce à la bibliothèque frontale. Mais pour Node.js, vous devez savoir exactement quelles opérations le moteur JavaScript V8 de Google prend en charge. De cette façon, vous pouvez utiliser directement ces méthodes intégrées pour opérer sur la collection côté serveur.

9. Utilisez Nginx devant Node

Nginx est un petit serveur Web léger qui peut réduire la charge sur votre serveur Node.js. Vous pouvez configurer des ressources statiques sur nginx au lieu de Node. Vous pouvez utiliser gzip pour compresser les réponses sur nginx, réduisant ainsi toutes les réponses. Donc, si vous avez un produit en cours d'exécution, je pense que vous souhaiterez utiliser nginx pour améliorer la vitesse d'exécution.

10. Emballage JavaScript

Enfin, vous pouvez également améliorer considérablement la vitesse d'application des pages en empaquetant plusieurs fichiers JS. Lorsque le navigateur rencontre l'élément