दिलचस्प पोस्ट
मैं एक घुमावदार मार्ग के साथ एक दृश्य या छवि के आंदोलन को कैसे सजीव कर सकता हूं? सी ++ 11 में स्ट्रिंग लीटरल्स के लिए यूनिकोड एन्कोडिंग संदर्भ: mod_rewrite, URL पुनर्लेखन और "सुंदर लिंक" समझाया MySQL में तालिका या स्तंभ नाम के रूप में एक आरक्षित शब्द का उपयोग करने के कारण सिंटैक्स त्रुटि PHP कुछ $ _POST मान अनुपलब्ध हैं लेकिन php: // इनपुट में मौजूद हैं Android Gradle प्लगइन 0.7 के साथ एनडीके को कॉन्फ़िगर कैसे करें पायथन में स्ट्रिंग खाली है या नहीं, यह जांचने के लिए सबसे शानदार तरीका है? जावास्क्रिप्ट: टाइमआउट के साथ लूप के लिए अजीब जावा व्यवहार टर्नरी ऑपरेटर एक सामान्य वेक्टर के आधार पर एक विमान प्लॉट करें और Matlab या matplotlib में एक बिंदु आप डब्ल्यूपीएफ में एपबार डॉकिंग कैसे कर सकते हैं (विन्ड एम्प की तरह) SSH पर फ़ाइलों को स्थानांतरित करना MySQL में नल (प्रदर्शन और संग्रहण) मैं कैसे जावास्क्रिप्ट भाषण की स्थिति को सिंक्रनाइज़ कर सकता हूं? PHP में शून्य बनाम झूठी बनाम 0

Node.js के साथ एक आदेश पंक्ति बाइनरी निष्पादित करें

मैं रूडी से Node.js. पर एक सीएलआई पुस्तकालय की प्रक्रिया में हूँ मेरे कोड में मैं आवश्यक होने पर कई तृतीय पक्ष के बायनेरी निष्पादित करता हूं मुझे यकीन नहीं है कि नोड में यह कैसे पूरा किया जाए।

यहां रूबी में एक उदाहरण है जहां मैं प्रिंसएक्सएमएल को एक फ़ाइल पीडीएफ में कनवर्ट करने के लिए कहता हूं:

cmd = system("prince -v builds/pdf/book.html -o builds/pdf/book.pdf") 

नोड में समकक्ष कोड क्या है?

वेब के समाधान से एकत्रित समाधान "Node.js के साथ एक आदेश पंक्ति बाइनरी निष्पादित करें"

Node.js (v8.1.4) के भी नए संस्करण के लिए, ईवेंट और कॉल्स पुराने संस्करणों के समान या समान हैं, लेकिन मानक नई भाषा सुविधाओं का उपयोग करने के लिए प्रोत्साहित किया गया है। उदाहरण:

बफर के लिए, गैर-स्ट्रीम स्वरूपित आउटपुट (आप इसे एक बार में प्राप्त करते हैं), child_process.exec उपयोग child_process.exec :

 const { exec } = require('child_process'); exec('cat *.js bad_file | wc -l', (err, stdout, stderr) => { if (err) { // node couldn't execute the command return; } // the *entire* stdout and stderr (buffered) console.log(`stdout: ${stdout}`); console.log(`stderr: ${stderr}`); }); 

आप इसे वादे के साथ भी उपयोग कर सकते हैं:

 const util = require('util'); const exec = util.promisify(require('child_process').exec); async function ls() { const { stdout, stderr } = await exec('ls'); console.log('stdout:', stdout); console.log('stderr:', stderr); } ls(); 

अगर आप धीरे-धीरे डेटा (धारा के रूप में आउटपुट) में डेटा प्राप्त करना चाहते हैं, तो child_process.spawn उपयोग child_process.spawn :

 const { spawn } = require('child_process'); const child = spawn('ls', ['-lh', '/usr']); // use child.stdout.setEncoding('utf8'); if you want text chunks child.stdout.on('data', (chunk) => { // data from standard output is here as buffers }); // since these are streams, you can pipe them elsewhere child.stderr.pipe(dest); child.on('close', (code) => { console.log(`child process exited with code ${code}`); }); 

इन दोनों कार्यों में एक तुल्यकालिक समकक्ष है child_process.execSync लिए एक उदाहरण:

 const { execSync } = require('child_process'); // stderr is sent to stdout of parent process // you can set options.stdio if you want it to go elsewhere let stdout = execSync('ls'); 

साथ ही साथ child_process.spawnSync :

 const { spawnSync} = require('child_process'); const child = spawnSync('ls', ['-lh', '/usr']); console.log('error', child.error); console.log('stdout ', child.stderr); console.log('stderr ', child.stderr); 

नोट: निम्न कोड अभी भी कार्यात्मक है, लेकिन प्राथमिक रूप से ES5 के उपयोगकर्ताओं और इससे पहले लक्ष्य है

नोड। जेएस के साथ बाल प्रक्रियाओं को विकसित करने के लिए मॉड्यूल दस्तावेज़ीकरण (v5.0.0) में अच्छी तरह से प्रलेखित है। कमांड को निष्पादित करने के लिए और बफर के रूप में अपना पूरा आउटपुट प्राप्त करने के लिए, child_process.exec उपयोग child_process.exec :

 var exec = require('child_process').exec; var cmd = 'prince -v builds/pdf/book.html -o builds/pdf/book.pdf'; exec(cmd, function(error, stdout, stderr) { // command output is in stdout }); 

यदि आपको धाराओं के साथ संभाल प्रक्रिया I / O का उपयोग करने की आवश्यकता है, जैसे कि जब आप बड़ी मात्रा में उत्पादन की उम्मीद कर रहे हैं, तो child_process.spawn उपयोग child_process.spawn :

 var spawn = require('child_process').spawn; var child = spawn('prince', [ '-v', 'builds/pdf/book.html', '-o', 'builds/pdf/book.pdf' ]); child.stdout.on('data', function(chunk) { // output will be here in chunks }); // or if you want to send output elsewhere child.stdout.pipe(dest); 

अगर आप कमांड के बजाय एक फ़ाइल निष्पादित कर रहे हैं, तो आप child_process.execFile का उपयोग करना child_process.execFile , जो पैरामीटर जो लगभग समान spawn , लेकिन आउटपुट बफ़र्स प्राप्त करने के लिए एक चौथा कॉलबैक पैरामीटर जैसे exec । यह कुछ इस तरह दिख सकता है:

 var execFile = require('child_process').execFile; execFile(file, args, options, function(error, stdout, stderr) { // command output is in stdout }); 

V0.11.12 के रूप में, नोड अब सिंक्रोनस spawn और exec का समर्थन करता है। ऊपर वर्णित सभी तरीके अतुल्यकालिक हैं, और एक तुल्यकालिक समकक्ष हैं। उनके लिए प्रलेखन यहां मिल सकते हैं । हालांकि वे स्क्रीप्टिंग के लिए उपयोगी हैं, ध्यान रखें कि बाल प्रक्रियाओं को अतुल्यकालिक रूप से इस्तेमाल करने के तरीकों के विपरीत, तुल्यकालिक तरीके ChildProcess का एक उदाहरण नहीं ChildProcess

नोड जेएस v9.2.0 , एलटीएस v8.9.1 , और v6.12.0 — नवंबर 2017

असिन्क और उचित विधि:

 'use strict'; const { spawn } = require( 'child_process' ), ls = spawn( 'ls', [ '-lh', '/usr' ] ); ls.stdout.on( 'data', data => { console.log( `stdout: ${data}` ); } ); ls.stderr.on( 'data', data => { console.log( `stderr: ${data}` ); } ); ls.on( 'close', code => { console.log( `child process exited with code ${code}` ); } ); 

सिंक:

 'use strict'; const { spawnSync } = require( 'child_process' ), ls = spawnSync( 'ls', [ '-lh', '/usr' ] ); console.log( `stderr: ${ls.stderr.toString()}` ); console.log( `stdout: ${ls.stdout.toString()}` ); 

Node.js v9.2.0 दस्तावेज़ीकरण से

वही नोड। जेएस v8.9.1 प्रलेखन और नोड। जेएस v6.12.0 दस्तावेज़ीकरण के लिए चला जाता है

आप child_process.exec के लिए देख रहे हैं

यहां एक उदाहरण है:

 const exec = require('child_process').exec; const child = exec('cat *.js bad_file | wc -l', (error, stdout, stderr) => { console.log(`stdout: ${stdout}`); console.log(`stderr: ${stderr}`); if (error !== null) { console.log(`exec error: ${error}`); } }); 

मैंने यूनिक्स / खिड़कियों से आसानी से निपटने के लिए सिर्फ एक क्ली सहायक लिखा है

जावास्क्रिप्ट:

 define(["require", "exports"], function (require, exports) { /** * Helper to use the Command Line Interface (CLI) easily with both Windows and Unix environments. * Requires underscore or lodash as global through "_". */ var Cli = (function () { function Cli() {} /** * Execute a CLI command. * Manage Windows and Unix environment and try to execute the command on both env if fails. * Order: Windows -> Unix. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @param callback Success. * @param callbackErrorWindows Failure on Windows env. * @param callbackErrorUnix Failure on Unix env. */ Cli.execute = function (command, args, callback, callbackErrorWindows, callbackErrorUnix) { if (typeof args === "undefined") { args = []; } Cli.windows(command, args, callback, function () { callbackErrorWindows(); try { Cli.unix(command, args, callback, callbackErrorUnix); } catch (e) { console.log('------------- Failed to perform the command: "' + command + '" on all environments. -------------'); } }); }; /** * Execute a command on Windows environment. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @param callback Success callback. * @param callbackError Failure callback. */ Cli.windows = function (command, args, callback, callbackError) { if (typeof args === "undefined") { args = []; } try { Cli._execute(process.env.comspec, _.union(['/c', command], args)); callback(command, args, 'Windows'); } catch (e) { callbackError(command, args, 'Windows'); } }; /** * Execute a command on Unix environment. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @param callback Success callback. * @param callbackError Failure callback. */ Cli.unix = function (command, args, callback, callbackError) { if (typeof args === "undefined") { args = []; } try { Cli._execute(command, args); callback(command, args, 'Unix'); } catch (e) { callbackError(command, args, 'Unix'); } }; /** * Execute a command no matters what's the environment. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @private */ Cli._execute = function (command, args) { var spawn = require('child_process').spawn; var childProcess = spawn(command, args); childProcess.stdout.on("data", function (data) { console.log(data.toString()); }); childProcess.stderr.on("data", function (data) { console.error(data.toString()); }); }; return Cli; })(); exports.Cli = Cli; }); 

टाइप स्क्रिप्ट मूल स्रोत फ़ाइल:

  /** * Helper to use the Command Line Interface (CLI) easily with both Windows and Unix environments. * Requires underscore or lodash as global through "_". */ export class Cli { /** * Execute a CLI command. * Manage Windows and Unix environment and try to execute the command on both env if fails. * Order: Windows -> Unix. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @param callback Success. * @param callbackErrorWindows Failure on Windows env. * @param callbackErrorUnix Failure on Unix env. */ public static execute(command: string, args: string[] = [], callback ? : any, callbackErrorWindows ? : any, callbackErrorUnix ? : any) { Cli.windows(command, args, callback, function () { callbackErrorWindows(); try { Cli.unix(command, args, callback, callbackErrorUnix); } catch (e) { console.log('------------- Failed to perform the command: "' + command + '" on all environments. -------------'); } }); } /** * Execute a command on Windows environment. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @param callback Success callback. * @param callbackError Failure callback. */ public static windows(command: string, args: string[] = [], callback ? : any, callbackError ? : any) { try { Cli._execute(process.env.comspec, _.union(['/c', command], args)); callback(command, args, 'Windows'); } catch (e) { callbackError(command, args, 'Windows'); } } /** * Execute a command on Unix environment. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @param callback Success callback. * @param callbackError Failure callback. */ public static unix(command: string, args: string[] = [], callback ? : any, callbackError ? : any) { try { Cli._execute(command, args); callback(command, args, 'Unix'); } catch (e) { callbackError(command, args, 'Unix'); } } /** * Execute a command no matters what's the environment. * * @param command Command to execute. ('grunt') * @param args Args of the command. ('watch') * @private */ private static _execute(command, args) { var spawn = require('child_process').spawn; var childProcess = spawn(command, args); childProcess.stdout.on("data", function (data) { console.log(data.toString()); }); childProcess.stderr.on("data", function (data) { console.error(data.toString()); }); } } Example of use: Cli.execute(Grunt._command, args, function (command, args, env) { console.log('Grunt has been automatically executed. (' + env + ')'); }, function (command, args, env) { console.error('------------- Windows "' + command + '" command failed, trying Unix... ---------------'); }, function (command, args, env) { console.error('------------- Unix "' + command + '" command failed too. ---------------'); }); 
 const exec = require("child_process").exec exec("ls", (error, stdout, stderr) => { //do whatever here }) 

संस्करण 4 के बाद से सबसे निकटतम विकल्प child_process.execSync विधि है:

 const execSync = require('child_process').execSync; var cmd = execSync('prince -v builds/pdf/book.html -o builds/pdf/book.pdf'); 

नोट करें कि यह विधि ईवेंट लूप ब्लॉक करता है।

यदि आप कुछ ऐसा चाहते हैं जो निकटता के शीर्ष उत्तर के निकट होता है, लेकिन तुल्यकालिक भी होता है तो यह काम करेगा।

 var exec = require('child_process').execSync; var cmd = "echo 'hello world'"; var options = { encoding: 'utf8' }; console.log(exec(cmd, options)); 

@ हेक्सैसाइनाइड का जवाब लगभग एक पूर्ण है विंडोज कमांड prince पर prince prince.exe , prince.cmd prince.exe , prince.cmd या सिर्फ prince (मुझे पता नहीं है कि रत्न कैसे बांधा जाता है, लेकिन एनपीएम डिब्बे एक स्क्रिप्ट और बैच स्क्रिप्ट के साथ आते हैं – npm और npm.cmd )। यदि आप एक पोर्टेबल स्क्रिप्ट लिखना चाहते हैं जो यूनिक्स और विंडोज पर चलती है, तो आपको सही निष्पादन योग्य पैदा करना होगा।

यहाँ एक सरल अभी तक पोर्टेबल स्पॉन फ़ंक्शन है:

 function spawn(cmd, args, opt) { var isWindows = /win/.test(process.platform); if ( isWindows ) { if ( !args ) args = []; args.unshift(cmd); args.unshift('/c'); cmd = process.env.comspec; } return child_process.spawn(cmd, args, opt); } var cmd = spawn("prince", ["-v", "builds/pdf/book.html", "-o", "builds/pdf/book.pdf"]) // Use these props to get execution results: // cmd.stdin; // cmd.stdout; // cmd.stderr; 

मुझे एक ही समस्या थी और मैं हमेशा के लिए मिला यह एक सीएलआई है जिसे आप एनपीएम के साथ स्थापित कर सकते हैं और यह मेरे रास्पबेरी पी के साथ पूरी तरह से ठीक काम किया है! और अगर आप इसे स्टार्टअप पर चलाना चाहते हैं, तो आप "हमेशा के लिए-सेवा" स्थापित कर सकते हैं वे आपको ऐप को बनाए रखने और हर समय चलने की आवश्यकता को स्थापित करेंगे!

एक नज़र देख लो!

https://github.com/zapty/forever-service

https://www.npmjs.com/package/forever