Explication détaillée de l'utilisation du module de processus de notes Node.js

Cette fois, je vous apporte une explication détaillée de l'utilisation du module de processus de prise de notes Node.js. Quelles sont les précautions lors de l'utilisation du module de processus de prise de notes Node.js. un cas pratique, jetons un coup d'oeil.

processus existe sur l'objet global et peut être utilisé sans utiliser require() pour le charger. Le module process fait principalement deux choses

1. . Lire : obtenir des informations sur le processus (utilisation des ressources, environnement d'exploitation, état de fonctionnement)

2. Écrire : effectuer des opérations de processus (écouter des événements, planifier des tâches, émettre des avertissements) Utilisation des ressources

Utilisation des ressources

fait référence aux ressources de la machine consommées par l'exécution de ce processus. Par exemple, la composition de la mémoire, cpu

mémoire

process.memoryUsage())
{ rss: 21848064,
 heapTotal: 7159808,
 heapUsed: 4431688,
 external: 8224 
 }

rss (mémoire résidente) est illustrée dans la figure ci-dessous

Le segment de code correspond au code en cours d'exécution

externe correspond à la mémoire occupée par l'objet C++ (lié à l'objet JS géré par V8), comme l'utilisation de Buffer

Buffer.allocUnsafe(1024 * 1024 * 1000);
console.log(process.memoryUsage());
{ rss: 22052864,
 heapTotal: 6635520,
 heapUsed: 4161376,
 external: 1048584224 }

cpu

const startUsage = process.cpuUsage();
console.log(startUsage);
const now = Date.now();
while (Date.now() - now < 500);
console.log(process.cpuUsage());
console.log(process.cpuUsage(startUsage)); //相对时间
// { user: 59459, system: 18966 }
// { user: 558135, system: 22312 }
// { user: 498432, system: 3333 }

l'utilisateur correspond à l'heure de l'utilisateur, le système représente l'heure du système

Environnement d'exécution

L'environnement d'exécution fait référence à l'environnement hôte dans lequel ce processus s'exécute, y compris le répertoire d'exécution, l'environnement de nœud, l'architecture du processeur, l'environnement utilisateur, la plate-forme système

Répertoire en cours d'exécution

const startUsage = process.cpuUsage();
console.log(startUsage);
const now = Date.now();
while (Date.now() - now < 500);
console.log(process.cpuUsage());
console.log(process.cpuUsage(startUsage)); //相对时间
// { user: 59459, system: 18966 }
// { user: 558135, system: 22312 }
// { user: 498432, system: 3333 }

environnement de nœud

console.log(process.version)
// v9.1.0

Si vous souhaitez non seulement obtenir les informations de version du nœud, mais également v8, zlib, version libuv et d'autres informations, vous devez utiliser process.versions

console.log(process.versions);
{ http_parser: '2.7.0',
 node: '9.1.0',
 v8: '6.2.414.32-node.8',
 uv: '1.15.0',
 zlib: '1.2.11',
 ares: '1.13.0',
 modules: '59',
 nghttp2: '1.25.0',
 openssl: '1.0.2m',
 icu: '59.1',
 unicode: '9.0',
 cldr: '31.0.1',
 tz: '2017b' }

architecture cpu

console.log(`This processor architecture is ${process.arch}`);
// This processor architecture is x64

Les valeurs prises en charge incluent : 'arm', 'arm64', 'ia32', 'mips', 'mipsel', 'ppc', 'ppc64' , 's390', 's390x', 'x32' 'x64'

Environnement utilisateur

console.log(process.env.NODE_ENV); // dev
NODE_ENV=dev node b.js

En plus des informations personnalisées au démarrage, process.env peut également obtenir d'autres informations sur l'environnement utilisateur (telles que PATH, SHELL, HOME, etc.), si vous êtes intéressé, vous pouvez l'imprimer vous-même et l'essayer

Plateforme système

console.log(`This platform is ${process.platform}`);
This platform is darwin

Les plates-formes système prises en charge incluent : 'aix' 'darwin' 'freebsd' 'linux' 'openbsd' 'sunos' 'win32'

Android est toujours en phase expérimentale

Statut d'exécution

Statut d'exécution Fait référence aux informations liées à l'exécution du processus en cours, y compris les paramètres de démarrage, le répertoire d'exécution, le fichier principal, le PID informations, durée d'exécution

Paramètres de démarrage

Il existe trois façons d'obtenir les paramètres de démarrage. execArgv obtient les options de ligne de commande de Node.js (voir la documentation officielle du site Web) <.>

argv obtient les informations sur les options hors ligne de commande, et argv0 obtient la valeur de argv[0] (légèrement différente)

console.log(process.argv)
console.log(process.argv0)
console.log(process.execArgv)
node --harmony b.js foo=bar --version
// 输出结果
[ '/Users/xiji/.nvm/versions/node/v9.1.0/bin/node',
 '/Users/xiji/workspace/learn/node-basic/process/b.js',
 'foo=bar',
 '--version' ]
node
[ '--harmony' ]

Répertoire d'exécution

console.log(process.execPath);
// /Users/xxxx/.nvm/versions/node/v9.1.0/bin/node

Temps d'exécution

var date = new Date();
while(new Date() - date < 500) {}
console.log(process.uptime()); // 0.569

Fichier principal

En plus de require.main, vous pouvez également utiliser process.mainModule pour déterminer si un module est un fichier principal

//a.js
console.log(`module A: ${process.mainModule === module}`);
//b.js
require('./a');
console.log(`module B: ${process.mainModule === module}`);
node b.js
// 输出
module A: false
module B: true

Informations PID

console.log(`This process is pid ${process.pid}`); //This process is pid 12554

Événements d'écoute

Les événements couramment utilisés incluent beforeExit, exit, Il existe deux différences entre non capturé

Exception, message

beforeExit et exit :

1. beforeExit peut exécuter du code asynchrone, et exit ne peut être que du code synchrone

<.>Le code appelle manuellement process.exit() ou déclenche uncaptException pour provoquer la sortie du processus. L'événement beforeExit ne sera pas déclenché, mais l'événement exit sera déclenché.
Par conséquent, la console de code suivante ne sera pas exécutée

process.on('beforeExit', function(code) {
 console.log('before exit: '+ code);
});
process.on('exit', function(code) {
 setTimeout(function() {
  console.log('exit: ' + code);
 }, 0);
});
a.b();

当异常一直没有被捕获处理的话，最后就会触发'uncaughtException'事件。默认情况下，Node.js会打印堆栈信息到stderr然后退出进程。不要试图阻止uncaughtException退出进程，因此此时程序的状态可能已经不稳定了，建议的方式是及时捕获处理代码中的错误，uncaughtException里面只做一些清理工作(可以执行异步代码）。

注意：node的9.3版本增加了process.setUncaughtExceptionCaptureCallback方法

当process.setUncaughtExceptionCaptureCallback(fn)指定了监听函数的时候，uncaughtException事件将会不再被触发。

process.on('uncaughtException', function() {
 console.log('uncaught listener');
});
process.setUncaughtExceptionCaptureCallback(function() {
 console.log('uncaught fn');
});
a.b();
// uncaught fn

message适用于父子进程之间发送消息，关于如何创建父子进程会放在child_process模块中进行。

调度任务

process.nextTick(fn)

通过process.nextTick调度的任务是异步任务，EventLoop是分阶段的，每个阶段执行特定的任务，而nextTick的任务在阶段切换的时候就会执行，因此nextTick会比setTimeout(fn, 0)更快的执行，关于EventLoop见下图，后面会做进一步详细的讲解

发出警告

process.emitWarning('Something warning happened!', {
 code: 'MY_WARNING',
 type: 'XXXX'
});
// (node:14771) [MY_WARNING] XXXX: Something warning happened!

当type为DeprecationWarning时，可以通过命令行选项施加影响

1. --throw-deprecation 会抛出异常

2. --no-deprecation 不输出DeprecationWarning

3. --trace-deprecation 打印详细堆栈信息

process.emitWarning('Something warning happened!', {
 type: 'DeprecationWarning'
});
console.log(4);
node --throw-deprecation index.js
node --no-deprecation index.js
node --trace-deprecation index.js

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

怎么使用webpack3.0配置webpack-dev-server

JS反射与依赖注入使用案例分析

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!