node.js thực thi lệnh hệ thống một cách đồng bộ

Tôi cần trong hàm node.js

result = execSync('node -v');

điều đó sẽ thực thi đồng bộ dòng lệnh đã cho và trả về tất cả các thiết bị xuất chuẩn của văn bản lệnh đó.

ps. Đồng bộ hóa là sai. Tôi biết. Chỉ để sử dụng cá nhân.

CẬP NHẬT

Bây giờ chúng tôi có giải pháp của mgutz cung cấp cho chúng tôi mã thoát, nhưng không xuất sắc! Vẫn đang chờ câu trả lời chính xác hơn.

CẬP NHẬT

mgutz cập nhật câu trả lời của mình và giải pháp là đây :)
Ngoài ra, như dgo.a đề cập, có độc lập mô-đun exec-sync

CẬP NHẬT 2014-07-30

ShellJS lib đã đến. Hãy coi đây là sự lựa chọn tốt nhất cho bây giờ.

CẬP NHẬT 2015/02/10

CUỐI CÙNG! NodeJS 0.12 hỗ trợ execSynchữu cơ.
Xem tài liệu chính thức

Node.js (kể từ phiên bản 0.12 - vì vậy trong một thời gian) hỗ trợ execSync:

child_process.execSync(command[, options])

Bây giờ bạn có thể trực tiếp làm điều này:

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

và nó sẽ làm những gì bạn mong đợi. (Mặc định để chuyển các kết quả i / o sang quy trình cha). Lưu ý rằng bạn cũng có thể spawnSyncbây giờ.

Xem thư viện execSync .

Nó khá dễ thực hiện với nút-ffi . Tôi sẽ không đề xuất cho các quy trình máy chủ, nhưng đối với các tiện ích phát triển chung, nó sẽ hoàn thành công việc. Cài đặt thư viện.

npm install node-ffi

Kịch bản ví dụ:

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

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

[EDIT tháng 6 năm 2012: Làm thế nào để mắc 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'));

Sử dụng ShellJS mô-đun .

thực hiệnHàm mà không cung cấp gọi lại.

Thí dụ:

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

Có một mô-đun tuyệt vời để kiểm soát luồng trong node.js được gọi là asyncblock . Nếu gói mã trong một hàm là OK cho trường hợp của bạn, mẫu sau có thể được xem xét:

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...');
});

Điều này là không thể có trong Node.js, cả child_process.spawnvàchild_process.exec được xây dựng từ đầu để trở thành không đồng bộ.

Để biết chi tiết, hãy xem: https://github.com/ry/node/blob/master/lib/child_ Process.js

Nếu bạn thực sự muốn có tính năng chặn này, sau đó đặt mọi thứ cần xảy ra sau đó trong một cuộc gọi lại hoặc xây dựng hàng đợi của riêng bạn để xử lý việc này theo kiểu chặn, tôi cho rằng bạn có thể sử dụng Async.js cho nhiệm vụ này.

Hoặc, trong trường hợp bạn có quá nhiều thời gian để chi tiêu, hãy tự hack trong Node.js.

Đây là cách dễ nhất tôi tìm thấy:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(Không bị nhầm lẫn với execSync.)
Thực thi lệnh shell một cách đồng bộ. Sử dụng điều này cho các tập lệnh di chuyển, chương trình cli, nhưng không phải cho mã máy chủ thông thường.

Thí dụ:

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

Chỉ cần thêm rằng mặc dù có một vài usecase mà bạn nên sử dụng chúng, spawnSync/ execFileSync/ execSyncđã được thêm vào node.js trong các cam kết này: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Bạn có thể đạt được điều này bằng cách sử dụng sợi. Ví dụ: sử dụng thư viện Nút chung của tôi , mã sẽ trông như thế này:

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

Tôi được sử dụng để thực hiện "synchronous"công cụ ở cuối chức năng gọi lại. Không đẹp lắm, nhưng nó hoạt động. Nếu bạn cần thực hiện một chuỗi các lệnh thực thi dòng lệnh, bạn cần gói execvào một số hàm được đặt tên và gọi đệ quy nó. Mẫu này dường như có thể sử dụng được cho tôi:

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);
        }
    });
};

Tôi đã có một vấn đề tương tự và cuối cùng tôi đã viết một phần mở rộng nút cho việc này. Bạn có thể kiểm tra kho git. Đó là nguồn mở và miễn phí và tất cả những thứ tốt!

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

ExecXI là một phần mở rộng nút được viết bằng C ++ để thực thi từng lệnh shell, xuất ra đầu ra của lệnh cho bàn điều khiển trong thời gian thực. Tùy chọn xiềng xích, và cách không rõ ràng có mặt; có nghĩa là bạn có thể chọn dừng tập lệnh sau khi lệnh bị lỗi (bị xiềng xích) hoặc bạn có thể tiếp tục như thể không có gì xảy ra!

Hướng dẫn sử dụng có trong tệp ReadMe . Hãy thoải mái thực hiện các yêu cầu kéo hoặc gửi vấn đề!

EDIT: Tuy nhiên, nó vẫn chưa trả về thiết bị xuất chuẩn ... Chỉ cần xuất chúng theo thời gian thực. Nó làm ngay bây giờ.Vâng, tôi vừa phát hành nó ngày hôm nay. Có lẽ chúng ta có thể xây dựng trên nó.

Dù sao, tôi nghĩ rằng nó là giá trị để đề cập đến nó.

bạn có thể thực hiện các thao tác shell đồng bộ trong nodejs như vậy:

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\\"));

EDIT - ví dụ này có nghĩa là cho các môi trường windows, điều chỉnh cho nhu cầu linux của riêng bạn nếu cần thiết

Tôi thực sự đã gặp phải tình huống cần chạy nhiều lệnh lần lượt từ tập lệnh cài đặt trước pack.json theo cách có thể hoạt động trên cả Windows và Linux / OSX, vì vậy tôi không thể dựa vào mô-đun không lõi.

Vì vậy, đây là những gì tôi đã đưa ra:

#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()

Bạn có thể sử dụng nó như thế này:

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

EDIT: như đã chỉ ra, điều này không thực sự trả về đầu ra hoặc cho phép bạn sử dụng kết quả của các lệnh trong chương trình Nút. Một ý tưởng khác cho điều đó là sử dụng backcalls LiveScript. http://livescript.net/