Module child_process de Node.js

Java FileModules intégrés de Node.js

Node.js est un environnement d'exécution JavaScript monothread, mais parfois nous devons exécuter des commandes système ou lancer d'autres programmes. Dans ce cas, nous devons utiliser lechild_processmodule.

child_processLe module permet aux applications Node.js de créer des processus enfants, qui peuvent exécuter des commandes système, lancer d'autres scripts ou programmes, et communiquer avec le processus parent.

Pourquoi avons-nous besoin de child_process ?

  1. Exécuter des commandes système: Par exemple, exécuterls、gitet d'autres outils en ligne de commande
  2. Exécuter des tâches gourmandes en CPU: Éviter de bloquer le thread principal de Node.js
  3. Interagir avec des programmes écrits dans d'autres langages: Par exemple, appeler des programmes Python ou C++
  4. Améliorer les performances de l'application: Utiliser pleinement les CPU multicœurs grâce au multi-processus

Quatre méthodes pour créer des processus enfants

1. exec() - Exécuter des commandes simples

exec()La méthode est utilisée pour exécuter des commandes shell simples et mettre en mémoire tampon les résultats de sortie.

Exemple

const { exec } = require('child_process');

exec('ls -l', (error, stdout, stderr) => {
  if (error) {
    console.error(`Erreur d'exécution: ${error}`);
    return;
  }
  console.log(`Sortie standard:\n${stdout}`);
  if (stderr) {
    console.error(`Sortie d'erreur standard:\n${stderr}`);
  }
});

Fonctionnalités：

  • Adapté à l'exécution de commandes simples
  • Renvoie la sortie complète mise en mémoire tampon
  • Possède une limite maximale de mémoire tampon (200KB par défaut)

2. execFile() - Exécuter des fichiers exécutables

execFile()Similaire àexec(), mais exécute directement le fichier au lieu de passer par l'interpréteur de commandes.

Exemple

const { execFile } = require('child_process');

execFile('node', ['--version'], (error, stdout, stderr) => {
  if (error) {
    throw error;
  }
  console.log(stdout);
});

Fonctionnalités：

  • Comparerexec()Plus sécurisé (ne passe pas par le shell)
  • Efficacité d'exécution supérieure
  • Impossible d'utiliser les fonctionnalités du shell (telles que les pipes, les jokers, etc.)

3. spawn() - Traitement en flux des processus enfants

spawn()La méthode utilise une interface de streaming pour gérer les entrées/sorties des processus enfants.

Exemple

const { spawn } = require('child_process');

const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {
  console.log(`Sortie standard: ${data}`);
});

ls.stderr.on('data', (data) => {
  console.error(`Sortie d'erreur standard: ${data}`);
});

ls.on('close', (code) => {
  console.log(`Code de sortie du processus enfant: ${code}`);
});

Fonctionnalités：

  • Adapté au traitement de grandes quantités de sortie
  • Traitement en streaming, haute efficacité mémoire
  • Peut traiter la sortie en temps réel

4. fork() - Créer des processus enfants Node.js

fork()Ouispawn()Un cas particulier de , spécifiquement utilisé pour créer de nouveaux processus Node.js.

Exemple

const { fork } = require('child_process');

const child = fork('child.js');

child.on('message', (msg) => {
  console.log('Message from child process:', msg);
});

child.send({ hello: 'world' });

Fonctionnalités：

  • Crée une nouvelle instance Node.js
  • Canal IPC (communication inter-processus) intégré
  • Adapté aux tâches gourmandes en CPU

Communication inter-processus (IPC)

Les processus parent et enfant peuvent communiquer viasend()etmessagedes événements.

Processus parent (parent.js):

Exemple

const { fork } = require('child_process');
const child = fork('child.js');

child.on('message', (msg) => {
  console.log('Processus parent a reçu :', msg);
});

child.send({ parent: 'Bonjour du parent' });

Processus enfant (child.js):

Exemple

process.on('message', (msg) => {
  console.log('Processus enfant a reçu :', msg);
  process.send({ child: 'Bonjour de l'enfant' });
});

Gestion des erreurs

Une gestion appropriée des erreurs des processus enfant est très importante :

Exemple

const { spawn } = require('child_process');
const child = spawn('some_command');

child.on('error', (err) => {
  console.error('Échec du démarrage du processus enfant:', err);
});

child.stderr.on('data', (data) => {
  console.error(`Erreur du processus enfant: ${data}`);
});

child.on('exit', (code, signal) => {
  if (code) console.log(`Code de sortie du processus enfant: ${code}`);
  if (signal) console.log(`Processus enfant terminé par le signal: ${signal}`);
});

Bonnes pratiques

  1. Sécurité: Éviter de transmettre directement les entrées utilisateur aux processus enfants
  2. Gestion des ressources: Nettoyer les processus enfants terminés en temps voulu
  3. Gestion des erreurs: Gérez toujours les événements d'erreur et de sortie
  4. Considérations de performance: Pour les processus enfants créés fréquemment, envisagez d'utiliser un pool de processus
  5. Compatibilité multiplateforme: Faites attention aux différences de commandes entre les différents systèmes d'exploitation

Résumé

child_processLe module est le module central de Node.js pour la gestion des processus enfants, offrant quatre méthodes pour créer des processus enfants :

  1. exec()- Adapté aux commandes simples
  2. execFile()- Adapté à l'exécution de fichiers exécutables
  3. spawn()- Adapté au traitement en flux
  4. fork()- Adapté à la création de processus enfants Node.js

Choisissez la méthode appropriée en fonction de vos besoins spécifiques, et faites attention à la gestion des erreurs et des ressources afin d'exploiter pleinement les capacités multiprocessus de Node.js.

Java FileModules intégrés de Node.js

Autres extensions