Node.js génère un processus enfant et obtient la sortie du terminal en direct

Question

J'ai un script qui sort 'hi', dort pendant une seconde, sort 'hi', dort pendant 1 seconde, et ainsi de suite, et ainsi de suite. Maintenant, j'ai pensé que je serais capable d'aborder ce problème avec ce modèle.

var spawn = require('child_process').spawn,
temp    = spawn('PATH TO SCRIPT WITH THE ABOVE BEHAVIOUR');

temp.stdout.pipe(process.stdout);

Le problème est que la tâche doit être terminée pour que le résultat s'affiche. Si je comprends bien, cela est dû au fait que le processus nouvellement créé prend le contrôle de l'exécution. De toute évidence, node.js ne prend pas en charge les threads, donc une solution ? Mon idée était d'exécuter deux instances, la première dans le but spécifique de créer la tâche et d'envoyer la sortie vers le processus de la deuxième instance, en considérant que cela peut être réalisé.

Answer 1

Je me suis retrouvé à avoir besoin de cette fonctionnalité assez souvent pour l'intégrer dans une bibliothèque appelée std-pour . Il devrait vous permettre d'exécuter une commande et de visualiser la sortie en temps réel. Pour l'installer, il suffit :

npm install std-pour

Il est alors assez simple d'exécuter une commande et de voir la sortie en temps réel :

const { pour } = require('std-pour');
pour('ping', ['8.8.8.8', '-c', '4']).then(code => console.log(`Error Code: ${code}`));

Il est basé sur la promesse, donc vous pouvez enchaîner plusieurs commandes. Il est même compatible avec la signature de fonction avec child_process.spawn donc il devrait pouvoir être remplacé partout où vous l'utilisez.

Answer 2

Ajout d'un échantillon pour exec car j'avais moi aussi besoin d'un retour d'information en direct et je n'en ai eu aucun avant la fin du script. exec fait retourner un Émetteur d'événements contrairement aux nombreuses affirmations selon lesquelles seuls spawn fonctionne de cette manière.

Cela complète le commentaire que j'ai fait à la réponse acceptée de manière plus approfondie.

L'interface pour exec est similaire à celle de spawn :

// INCLUDES
import * as childProcess from 'child_process'; // ES6 Syntax

// DEFINES
let exec = childProcess.exec; // Use 'var' for more proper 
                              // semantics, or 'const' it all
                              // if that's your thing; though 'let' is 
                              // true-to-scope;

// Return an EventEmitter to work with, though
// you can also chain stdout too: 
// (i.e. exec( ... ).stdout.on( ... ); )
let childProcess = exec
(
    './binary command -- --argument argumentValue',
    ( error, stdout, stderr ) =>
    {    // When the process completes:
        if( error )
        {   
            console.log( `${error.name}: ${error.message}` );
            console.log( `[STACK] ${error.stack}` );
        }

        console.log( stdout );
        console.log( stderr );
        callback();                // Gulp stuff
    }
);

Maintenant, il suffit d'enregistrer un gestionnaire d'événement pour stdout :

childProcess.stdout.on( 'data', data => console.log( data ) );

Et pour stderr :

childProcess.stderr.on( 'data', data => console.log( `[ERROR]: ${data}` ) );

Vous pouvez également pipe stdout vers le stdout du processus principal :

childProcess.stdout.pipe( process.stdout );

Pas trop mal du tout - HTH

Answer 3

J'ai rencontré une situation où aucun des éléments ci-dessus ne fonctionnait lorsque je générais un script Python 3. Je recevais des données de stdout, mais seulement une fois que l'enfant se terminait.

Il s'avère que Python met en mémoire tampon stdout par défaut. Il est possible de désactiver la mise en mémoire tampon de stdout en incluant -u en tant que paramètre de ligne de commande pour python3.