Module perf_hooks de Node.js

Java FileModules intégrés de Node.js

de Node.jsperf_hooksLe module est un outil de surveillance des performances qui permet aux développeurs de mesurer et de surveiller les performances d'exécution du code dans les applications. Ce module fournit des fonctionnalités de chronométrage de haute précision pour vous aider à identifier les goulots d'étranglement de performance dans votre code.

perf_hooksIl s'agit de l'abréviation de « Performance Hooks ». Fondé sur la norme Web Performance API, il fournit des capacités de mesure des performances pour les applications Node.js.

Fonctionnalités principales de perf_hooks

1. Chronométrage des performances

perf_hooksLe module peut mesurer précisément le temps d'exécution de blocs de code, avec une précision de l'ordre de la nanoseconde.

2. Surveillance des ressources

Il peut surveiller l'utilisation des ressources des processus Node.js, y compris le temps CPU, l'utilisation de la mémoire, etc.

3. Observation des performances

Il fournit un patron observateur pour surveiller en continu certains types de métriques de performance.

Comment utiliser perf_hooks

Tout d'abord, vous devez importerperf_hooksle module :

const { performance, PerformanceObserver } = require('perf_hooks');

Exemple de mesure de performance de base

Exemple

const { performance } = require('perf_hooks');

// Enregistrer le temps de début
const startTime = performance.now();

// Effectuer quelques opérations
for (let i = 0; i < 1000000; i++) {
    Math.sqrt(i);
}

// Enregistrer le temps de fin
const endTime = performance.now();

console.log(`Cette exécution de code a pris: ${endTime - startTime}millisecondes`);

Utilisation de PerformanceObserver

PerformanceObserverVous pouvez écouter les entrées de performance et répondre :

Exemple

const { PerformanceObserver, performance } = require('perf_hooks');

const obs = new PerformanceObserver((items) => {
    console.log(items.getEntries()[0].duration);
    performance.clearMarks();
});

obs.observe({ entryTypes: ['measure'] });

performance.mark('A');
doSomeLongOperation();
performance.mark('B');
performance.measure('A to B', 'A', 'B');

API principales de perf_hooks

1. performance.now()

Renvoie l'horodatage actuel à haute résolution, en millisecondes.

2. performance.mark(name)

Crée un marqueur d'horodatage nommé dans la chronologie de performance.

3. performance.measure(name, startMark, endMark)

Mesure l'intervalle de temps entre deux marqueurs.

4. PerformanceObserver

Une classe utilisée pour observer les événements de mesure de performance.

5. performance.timerify(fn)

Enveloppe une fonction afin que son temps d'exécution puisse être mesuré.

Scénarios d'application pratiques

1. Surveillance du temps de réponse de l'API

Exemple

const { performance } = require('perf_hooks');

app.use((req, res, next) => {
    const start = performance.now();
    res.on('finish', () => {
        console.log(`${req.method} ${req.url} ${performance.now() - start}ms`);
    });
    next();
});

2. Analyse des performances des fonctions

Exemple

const { performance, PerformanceObserver } = require('perf_hooks');

const obs = new PerformanceObserver((list) => {
    const entries = list.getEntries();
    entries.forEach((entry) => {
        console.log(`Fonction ${entry.name} a pris ${entry.duration}ms`);
    });
});
obs.observe({ entryTypes: ['function'] });

function slowFunction() {
    // Quelques opérations chronophages
}

// Utiliser timerify pour envelopper une fonction
const timedSlowFunction = performance.timerify(slowFunction);

timedSlowFunction();

Précautions

  1. perf_hooksLa mesure des performances entraîne elle-même une certaine surcharge de performance et doit être utilisée avec prudence dans les environnements de production.

  2. Les résultats de mesure du temps sont affectés par la charge du système et d'autres facteurs, il faut donc effectuer plusieurs mesures et en faire la moyenne.

  3. Dans différentes versions de Node.js,perf_hooksl'implémentation peut différer, et la compatibilité des versions doit être prise en compte.

  4. Pour des opérations très courtes (au niveau de la nanoseconde), les résultats de mesure peuvent ne pas être suffisamment précis.

Résumé

de Node.jsperf_hooksLe module offre aux développeurs de puissantes capacités de surveillance des performances, aidant à identifier et optimiser les goulots d'étranglement de performance dans le code. Grâce à une utilisation raisonnableperformanceetPerformanceObserver, les développeurs peuvent obtenir des données de performance précises, ce qui permet de prendre des décisions d'optimisation plus ciblées.

Dans les projets réels, il est recommandé d'intégrer la surveillance des performances au système de journalisation et d'établir des bases de référence de performance à long terme pour détecter rapidement les problèmes de régression de performance.

Java FileModules intégrés de Node.js

Autres extensions