node.js รันคำสั่งระบบพร้อมกัน

ฉันต้องการฟังก์ชั่นnode.js

result = execSync('node -v');

ที่จะพร้อมดำเนินการบรรทัดคำสั่งที่กำหนดและกลับ stdout'ed ทั้งหมดของข้อความคำสั่งที่

PS การซิงค์ผิด ฉันรู้ว่า. เพียงเพื่อการใช้งานส่วนตัว

UPDATE

ตอนนี้เรามีวิธีการแก้ปัญหาของ mgutz ซึ่งให้รหัสออก แต่ไม่ใช่ stdout! ยังคงรอคำตอบที่แม่นยำยิ่งขึ้น

UPDATE

mgutzอัปเดตคำตอบของเขาและวิธีแก้ปัญหาอยู่ที่นี่ :)
นอกจากนี้ตามที่dgo.aกล่าวว่ามีโมดูลแบบสแตนด์อโลนexec-sync

อัพเดท 2014-07-30

ShellJS lib มาถึงแล้ว พิจารณาว่านี่เป็นตัวเลือกที่ดีที่สุดในตอนนี้

อัพเดท 2015-02-10

ในที่สุด! NodeJS 0.12 รองรับexecSyncโดยกำเนิด
ดูเอกสารอย่างเป็นทางการ

Node.js (ตั้งแต่รุ่น 0.12 เป็นต้นไป) execSync:

child_process.execSync(command[, options])

ตอนนี้คุณสามารถทำสิ่งนี้โดยตรง:

const execSync = require('child_process').execSync;
code = execSync('node -v');

และมันจะทำสิ่งที่คุณคาดหวัง (ค่าดีฟอลต์คือไพพ์ผลลัพธ์ i / o ไปยังกระบวนการพาเรนต์) โปรดทราบว่าคุณสามารถทำได้ในspawnSyncตอนนี้

ดูไลบรารีexecSync

มันค่อนข้างง่ายที่จะทำอย่างไรกับโหนด FFI ฉันจะไม่แนะนำสำหรับกระบวนการเซิร์ฟเวอร์ แต่สำหรับยูทิลิตี้การพัฒนาทั่วไปมันก็เสร็จสิ้นแล้ว ติดตั้งห้องสมุด

npm install node-ffi

สคริปต์ตัวอย่าง:

var FFI = require("node-ffi");
var libc = new FFI.Library(null, {
  "system": ["int32", ["string"]]
});

var run = libc.system;
run("echo $USER");

[แก้ไข มิ.ย. 2555: วิธีรับ STDOUT]

var lib = ffi.Library(null, {
    // FILE* popen(char* cmd, char* mode);
    popen: ['pointer', ['string', 'string']],

    // void pclose(FILE* fp);
    pclose: ['void', [ 'pointer']],

    // char* fgets(char* buff, int buff, in)
    fgets: ['string', ['string', 'int','pointer']]
});

function execSync(cmd) {
  var
    buffer = new Buffer(1024),
    result = "",
    fp = lib.popen(cmd, 'r');

  if (!fp) throw new Error('execSync error: '+cmd);

  while(lib.fgets(buffer, 1024, fp)) {
    result += buffer.readCString();
  };
  lib.pclose(fp);

  return result;
}

console.log(execSync('echo $HOME'));

ใช้โมดูลShellJS

ฟังก์ชั่นexecโดยไม่ต้องให้การโทรกลับ

ตัวอย่าง:

var version = exec('node -v').output;

มีโมดูลที่ยอดเยี่ยมสำหรับการควบคุมการไหลใน Node.js เรียกว่าเป็นasyncblock หากการตัดโค้ดในฟังก์ชั่นนั้นใช้ได้สำหรับกรณีของคุณตัวอย่างต่อไปนี้อาจได้รับการพิจารณา:

var asyncblock = require('asyncblock');
var exec = require('child_process').exec;

asyncblock(function (flow) {
    exec('node -v', flow.add());
    result = flow.wait();
    console.log(result);    // There'll be trailing \n in the output

    // Some other jobs
    console.log('More results like if it were sync...');
});

สิ่งนี้เป็นไปไม่ได้ใน Node.js ทั้งสองchild_process.spawnและchild_process.execถูกสร้างขึ้นจากพื้นดินเป็น async

ดูรายละเอียดได้ที่: https://github.com/ry/node/blob/master/lib/child_process.js

หากคุณต้องการให้มีการบล็อกนี้ให้ใส่ทุกอย่างที่ต้องเกิดขึ้นหลังจากนั้นในการติดต่อกลับหรือสร้างคิวของคุณเองเพื่อจัดการสิ่งนี้ในแบบบล็อกฉันคิดว่าคุณสามารถใช้Async.jsสำหรับงานนี้

หรือในกรณีที่คุณมีเวลามากเกินไปให้แฮ็คใน Node.js ด้วยตนเอง

นี่เป็นวิธีที่ง่ายที่สุดที่ฉันพบ:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(เพื่อไม่ให้สับสนกับ execSync) เรียกใช้
คำสั่งเชลล์แบบซิงโครนัส ใช้สิ่งนี้สำหรับสคริปต์การโอนย้ายโปรแกรม cli แต่ไม่ใช่สำหรับรหัสเซิร์ฟเวอร์ปกติ

ตัวอย่าง:

var execSync = require('exec-sync');   
var user = execSync('echo $USER');
console.log(user);

เพียงแค่เพิ่มว่าแม้ว่าจะมีเพียงไม่กี่ usecases ที่คุณควรใช้พวกเขาspawnSync/ execFileSync/ execSyncถูกเพิ่มไปยัง node.js ในการกระทำเหล่านี้: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

คุณสามารถทำได้โดยใช้เส้นใย ตัวอย่างเช่นการใช้ไลบรารี Common Nodeของฉันโค้ดจะมีลักษณะดังนี้:

result = require('subprocess').command('node -v');

ฉันคุ้นเคยกับการใช้"synchronous"สิ่งต่าง ๆ ในตอนท้ายของฟังก์ชั่นโทรกลับ ไม่ค่อยดี แต่ใช้งานได้ หากคุณจำเป็นต้องใช้ลำดับของการดำเนินการบรรทัดคำสั่งคุณจำเป็นต้องตัดexecเข้าไปในฟังก์ชั่นที่มีชื่อและเรียกมันซ้ำ รูปแบบนี้ดูเหมือนจะใช้งานได้สำหรับฉัน:

SeqOfExec(someParam);

function SeqOfExec(somepParam) {
    // some stuff
    // .....
    // .....

    var execStr = "yourExecString";
    child_proc.exec(execStr, function (error, stdout, stderr) {
        if (error != null) {
            if (stdout) {
                throw Error("Smth goes wrong" + error);
            } else {
                // consider that empty stdout causes
                // creation of error object
            }
        }
        // some stuff
        // .....
        // .....

        // you also need some flag which will signal that you 
        // need to end loop
        if (someFlag ) {
            // your synch stuff after all execs
            // here
            // .....
        } else {
            SeqOfExec(someAnotherParam);
        }
    });
};

ฉันมีปัญหาที่คล้ายกันและฉันสิ้นสุดการเขียนโหนดส่วนขยายสำหรับสิ่งนี้ คุณสามารถตรวจสอบที่เก็บ git มันเป็นโอเพนซอร์สและฟรีและทุกสิ่งที่ดี!

https://github.com/aponxi/npm-execxi

ExecXI เป็นส่วนขยายโหนดที่เขียนใน C ++ เพื่อรันคำสั่งเชลล์ทีละคำสั่งเอาท์พุทคำสั่งไปยังคอนโซลแบบเรียลไทม์ ทางเลือกที่ถูกผูกมัดและไม่ จำกัด มีอยู่; หมายความว่าคุณสามารถเลือกที่จะหยุดสคริปต์หลังจากคำสั่งล้มเหลว (ถูกล่ามโซ่) หรือคุณสามารถดำเนินการต่อราวกับว่าไม่มีอะไรเกิดขึ้น!

คำแนะนำการใช้งานอยู่ในไฟล์ ReadMe รู้สึกฟรีเพื่อดึงคำขอหรือส่งปัญหา!

แก้ไข: อย่างไรก็ตามมันยังไม่ส่งคืน stdout เลย ... เพียงแค่แสดงผลแบบเรียลไทม์ มันทำตอนนี้ ฉันเพิ่งปล่อยมันวันนี้ บางทีเราสามารถสร้างมันขึ้นมาได้

อย่างไรก็ตามฉันคิดว่ามันคุ้มค่าที่จะพูดถึงมัน

คุณสามารถทำการเชลล์แบบซิงโครนัสใน nodejs ได้

var execSync = function(cmd) {

    var exec  = require('child_process').exec;
    var fs = require('fs');

    //for linux use ; instead of &&
    //execute your command followed by a simple echo 
    //to file to indicate process is finished
    exec(cmd + " > c:\\stdout.txt && echo done > c:\\sync.txt");

    while (true) {
        //consider a timeout option to prevent infinite loop
        //NOTE: this will max out your cpu too!
        try {
            var status = fs.readFileSync('c:\\sync.txt', 'utf8');

            if (status.trim() == "done") {
                var res = fs.readFileSync("c:\\stdout.txt", 'utf8');
                fs.unlinkSync("c:\\stdout.txt"); //cleanup temp files
                fs.unlinkSync("c:\\sync.txt");
                return res;
            }
        } catch(e) { } //readFileSync will fail until file exists
    }

};

//won't return anything, but will take 10 seconds to run
console.log(execSync("sleep 10")); 

//assuming there are a lot of files and subdirectories, 
//this too may take a while, use your own applicable file path
console.log(execSync("dir /s c:\\usr\\docs\\"));

แก้ไข - ตัวอย่างนี้มีไว้สำหรับสภาพแวดล้อม windows ปรับสำหรับความต้องการของคุณเอง linux หากจำเป็น

จริง ๆ แล้วฉันมีสถานการณ์ที่ฉันต้องการเรียกใช้คำสั่งหลายคำสั่งทีละคำสั่งจาก package.json ติดตั้งสคริปต์ล่วงหน้าเพื่อให้ทำงานได้ทั้งบน Windows และ Linux / OSX ดังนั้นฉันจึงไม่สามารถพึ่งพาโมดูลที่ไม่ใช่คอร์ได้

ดังนั้นนี่คือสิ่งที่ฉันมาด้วย:

#cmds.coffee
childproc = require 'child_process'

exports.exec = (cmds) ->
  next = ->
    if cmds.length > 0
      cmd = cmds.shift()
      console.log "Running command: #{cmd}"
      childproc.exec cmd, (err, stdout, stderr) ->
        if err? then console.log err
        if stdout? then console.log stdout
        if stderr? then console.log stderr
        next()
    else
      console.log "Done executing commands."

  console.log "Running the follows commands:"
  console.log cmds
  next()

คุณสามารถใช้สิ่งนี้:

require('./cmds').exec ['grunt coffee', 'nodeunit test/tls-config.js']

แก้ไข: ตามที่กล่าวมาสิ่งนี้จะไม่ส่งคืนผลลัพธ์จริงหรืออนุญาตให้คุณใช้ผลลัพธ์ของคำสั่งในโปรแกรม Node อีกแนวคิดหนึ่งสำหรับการใช้ LiveScript backcalls http://livescript.net/