Node.js स्पॉन चाइल्ड प्रोसेस और टर्मिनल आउटपुट को लाइव करते हैं




spawn capture-output (5)

मेरे पास एक स्क्रिप्ट है जो 'हाय' को आउटपुट करती है, एक सेकंड के लिए सोती है, 'हाय' को आउटपुट करती है, 1 सेकंड के लिए सोती है, और इसी तरह आगे भी। अब मैंने सोचा कि मैं इस मॉडल के साथ इस समस्या से निपटने में सक्षम हूं।

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

temp.stdout.pipe(process.stdout);

अब समस्या यह है कि आउटपुट को प्रदर्शित करने के लिए कार्य को समाप्त करने की आवश्यकता है। जैसा कि मैं इसे समझ रहा हूं, यह इस तथ्य के कारण है कि नव स्पंदित प्रक्रिया निष्पादन नियंत्रण लेती है। जाहिर है नोड। जे एस किसी भी समाधान का समर्थन नहीं करता है? मेरा विचार संभवतः दो उदाहरणों को चलाना था, पहला जो कार्य को बनाने के विशिष्ट उद्देश्य के लिए था और यह दूसरी आवृत्ति की प्रक्रिया के लिए आउटपुट को पाइप करता है, इस पर विचार किया जा सकता है।


जब मुझे एक बच्चे की प्रक्रिया में npm spawned था, तो मुझे "npm install" कमांड से लॉगिंग आउटपुट प्राप्त करने में थोड़ी परेशानी हुई। निर्भरता का वास्तविक समय लॉगिंग माता-पिता के कंसोल में नहीं दिखा।

मूल पोस्टर क्या चाहता है ऐसा करने का सबसे सरल तरीका लगता है (विंडोज़ पर स्पॉन एनपीएम और पेरेंट कंसोल के लिए सब कुछ लॉग इन करें):

var args = ['install'];

var options = {
    stdio: 'inherit' //feed all child process logging into parent process
};

var childProcess = spawn('npm.cmd', args, options);
childProcess.on('close', function(code) {
    process.stdout.write('"npm install" finished with code ' + code + '\n');
});

बच्चे:

setInterval(function() {
    process.stdout.write("hi");
}, 1000); // or however else you want to run a timer

माता-पिता:

require('child_process').fork('./childfile.js');
// fork'd children use the parent's stdio

मैंने खुद को इस कार्यक्षमता की आवश्यकता के लिए पर्याप्त पाया कि मैंने इसे एक पुस्तकालय में std-pour कहा। यह आपको एक कमांड निष्पादित करने और वास्तविक समय में आउटपुट देखने देना चाहिए। बस स्थापित करने के लिए:

npm install std-pour

फिर एक कमांड को निष्पादित करना और रियलटाइम में आउटपुट देखना काफी सरल है:

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

यह वादा किया गया है ताकि आप कई कमांड को चेन कर सकें। यहां तक ​​कि यह nodejs.org/api/… के साथ भी फंक्शन सिग्नेचर- nodejs.org/api/… इसलिए इसे आपके द्वारा उपयोग किए जा रहे कहीं भी रिप्लेसमेंट में होना चाहिए।


यह अब बहुत आसान है (2 साल बाद)!

स्पॉन एक चाइल्ड ऑबजेक्ट लौटाता है, जिसके साथ आप घटनाओं को सुन सकते हैं। घटनाएँ हैं:

  • क्लास: चाइल्डप्रोसेस
    • घटना: 'त्रुटि'
    • घटना: 'बाहर निकलें'
    • घटना: 'करीब'
    • घटना: 'डिस्कनेक्ट'
    • घटना: 'संदेश'

चाइल्डऑबजेक्ट से वस्तुओं का एक गुच्छा भी है, वे हैं:

  • क्लास: चाइल्डप्रोसेस
    • child.stdin
    • child.stdout
    • child.stderr
    • child.stdio
    • child.pid
    • child.connected
    • child.kill ([संकेत])
    • child.send (संदेश [, sendHandle] [, callback])
    • child.disconnect ()

चाइल्डऑबजेक्ट के बारे में अधिक जानकारी यहाँ देखें: https://nodejs.org/api/child_process.html

तो, यह सब मिलाकर, आपको मिलता है:

var spawn = require('child_process').spawn;
var child = spawn('node ./commands/server.js');
child.stdout.on('data', function(data) {
    console.log('stdout: ' + data);
    //Here is where the output goes
});
child.stderr.on('data', function(data) {
    console.log('stderr: ' + data);
    //Here is where the error output goes
});
child.on('close', function(code) {
    console.log('closing code: ' + code);
    //Here you can get the exit code of the script
});

और यह है कि आप नोड के साथ आउटपुट कैसे प्राप्त कर सकते हैं!


child_process.exec से संबंधित उत्तर जोड़ना क्योंकि मुझे भी लाइव फीडबैक की आवश्यकता थी और स्क्रिप्ट समाप्त होने के बाद तक कोई भी नहीं मिल रहा था। यह स्वीकृत उत्तर के लिए मेरी टिप्पणी को भी पूरक करता है, लेकिन जैसा कि यह स्वरूपित है यह थोड़ा और अधिक समझने और पढ़ने में आसान होगा।

मूल रूप से, मेरे पास एक एनपीएम स्क्रिप्ट है, जो कि एक कार्य को लागू करती है, जो ओएस के आधार पर एक बैश या बैच स्क्रिप्ट को निष्पादित करने के लिए एक कार्य को लागू करती है, जो बाद में child_process.exec का उपयोग child_process.exec है। या तो स्क्रिप्ट, गुल के माध्यम से एक निर्माण प्रक्रिया चलाती है और फिर कुछ बायनेरिज़ को कुछ कॉल करती है जो कि गुल्प आउटपुट के साथ काम करती है।

यह बिल्कुल दूसरों की तरह है (स्पॉन, आदि), लेकिन पूरा होने की खातिर, यहाँ बिल्कुल यह है कि यह कैसे किया जाए:

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


// GLOBALS
let exec = childProcess.exec; // Or use 'var' for more proper 
                              // semantics, though 'let' is 
                              // true-to-scope


// Assign exec to a variable, or chain stdout at the end of the call
// to exec - the choice, yours (i.e. exec( ... ).stdout.on( ... ); )
let childProcess = exec
(
    './binary command -- --argument argumentValue',
    ( error, stdout, stderr ) =>
    {
        if( error )
        {
            // This won't show up until the process completes:
            console.log( '[ERROR]: "' + error.name + '" - ' + error.message );
            console.log( '[STACK]: ' + error.stack );

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

        // Neither will this:
        console.log( stdout );
        console.log( stderr );
        callback();                // Gulp stuff
    }
);

अब यह एक इवेंट श्रोता को जोड़ने के रूप में सरल है। stdout :

childProcess.stdout.on
(
    'data',
    ( data ) =>
    {
        // This will render 'live':
        console.log( '[STDOUT]: ' + data );
    }
);

और stderr :

childProcess.stderr.on
(
    'data',
    ( data ) =>
    {
        // This will render 'live' too:
        console.log( '[STDERR]: ' + data );
    }
);

बहुत बुरा नहीं है - HTH





capture-output