Node.js를 사용하여 명령 줄 바이너리를 실행

해결법

1.Node.js를 (V8.1.4)의 경우에도 새로운 버전의 경우, 이벤트 및 호출은 유사하거나 이전 버전과 동일하지만,이 표준 새로운 언어 기능을 사용하는 것이 좋습니다 것. 예를 들면 :

Node.js를 (V8.1.4)의 경우에도 새로운 버전의 경우, 이벤트 및 호출은 유사하거나 이전 버전과 동일하지만,이 표준 새로운 언어 기능을 사용하는 것이 좋습니다 것. 예를 들면 :

버퍼를 들어, 비 스트림, 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 :
```
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 stderr 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.stdout);
console.log('stderr ', child.stderr);
```
참고 : 다음 코드는 여전히 작동하지만, 주로 ES5와 전 사용자를 대상으로합니다.

Node.js를 가진 자식 프로세스를 산란을위한 모듈은 물론 문서 (v5.0.0)에 설명되어 있습니다. 명령을 실행하고, 버퍼의 출력을 완료를 가져, 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 :
```
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, 산란 거의 동일 매개 변수를 사용하기를 원하지만 출력 버퍼를 검색 간부 등의 네 번째 콜백 매개 변수가 있습니다. 즉,이 같은 비트를 보일 수 있습니다 :
```
var execFile = require('child_process').execFile;
execFile(file, args, options, function(error, stdout, stderr) {
  // command output is in stdout
});
```
v0.11.12로, 노드는 이제 동기 산란 간부을 지원합니다. 전술 한 방법 전부는 비동기 및 동기 대응있다. 그들에 대한 문서는 여기에서 찾을 수 있습니다. 그들이 스크립팅에 유용하지만, 산란 아이에게 사용되는 방법은 비동기 적으로 처리 달리, 동기 방법 ChildProcess의 인스턴스를 반환하지 않는 점에 유의을한다.

2.

비동기 방법 (UNIX)

'use strict';

const { spawn } = require( 'child_process' );
const 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 { spawn } = require( 'child_process' );
const dir = spawn('cmd', ['/c', 'dir'])

dir.stdout.on( 'data', data => console.log( `stdout: ${data}` ) );
dir.stderr.on( 'data', data => console.log( `stderr: ${data}` ) );
dir.on( 'close', code => console.log( `child process exited with code ${code}` ) );

동조:

'use strict';

const { spawnSync } = require( 'child_process' );
const ls = spawnSync( 'ls', [ '-lh', '/usr' ] );

console.log( `stderr: ${ls.stderr.toString()}` );
console.log( `stdout: ${ls.stdout.toString()}` );

Node.js를의 v13.9.0 문서에서

동일은 Node.js를의 v12.16.1 문서 및 Node.js를의 v10.19.0 문서에 간다

3.당신은 child_process.exec를 찾고 있습니다

당신은 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}`);
        }
});

4.버전 4부터 가장 가까운 대안은 child_process.execSync 방법입니다 :

버전 4부터 가장 가까운 대안은 child_process.execSync 방법입니다 :
```
const {execSync} = require('child_process');

let output = execSync('prince -v builds/pdf/book.html -o builds/pdf/book.pdf');
```

5.

const exec = require("child_process").exec
exec("ls", (error, stdout, stderr) => {
 //do whatever here
})

6.당신은 밀접하게 최고 응답과 유사하지만,이 의지 작업 후 동기 뭔가를합니다.

당신은 밀접하게 최고 응답과 유사하지만,이 의지 작업 후 동기 뭔가를합니다.
```
var execSync = require('child_process').execSync;
var cmd = "echo 'hello world'";

var options = {
  encoding: 'utf8'
};

console.log(execSync(cmd, options));
```

7.난 그냥 쉽게 유닉스 / 윈도우 다루는 CLI 도우미를 썼다.

난 그냥 쉽게 유닉스 / 윈도우 다루는 CLI 도우미를 썼다.

자바 스크립트 :

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

8.당신은 의존성을 마음과 사용의 약속, 아이 프로세스 약속 작품 원하지 않는 경우 :

당신은 의존성을 마음과 사용의 약속, 아이 프로세스 약속 작품 원하지 않는 경우 :

설치

npm install child-process-promise --save

간부 사용법

var exec = require('child-process-promise').exec;

exec('echo hello')
    .then(function (result) {
        var stdout = result.stdout;
        var stderr = result.stderr;
        console.log('stdout: ', stdout);
        console.log('stderr: ', stderr);
    })
    .catch(function (err) {
        console.error('ERROR: ', err);
    });

산란 사용

var spawn = require('child-process-promise').spawn;

var promise = spawn('echo', ['hello']);

var childProcess = promise.childProcess;

console.log('[spawn] childProcess.pid: ', childProcess.pid);
childProcess.stdout.on('data', function (data) {
    console.log('[spawn] stdout: ', data.toString());
});
childProcess.stderr.on('data', function (data) {
    console.log('[spawn] stderr: ', data.toString());
});

promise.then(function () {
        console.log('[spawn] done!');
    })
    .catch(function (err) {
        console.error('[spawn] ERROR: ', err);
    });

9.다음과 같이 이제 (노드 V4에서) shelljs을 사용할 수 있습니다 :

다음과 같이 이제 (노드 V4에서) shelljs을 사용할 수 있습니다 :
```
var shell = require('shelljs');

shell.echo('hello world');
shell.exec('node --version')
```
10.이 경량 NPM 패키지를 사용하여 시스템 명령을

이 경량 NPM 패키지를 사용하여 시스템 명령을

여기 봐.

이런 식으로 가져 오기 :
```
const system = require('system-commands')
```
이 같은 실행 명령 :
```
system('ls').then(output => {
    console.log(output)
}).catch(error => {
    console.error(error)
})
```
11.@ hexacyanide의 대답은 거의 완전한 하나입니다. Windows 명령 왕자 prince.exe, prince.cmd, prince.bat하거나 왕자가 될 수에 (나는 보석이 번들로 제공하는 방법의 더 알고 있어요,하지만 NPM 쓰레기통은 쉬 스크립트와 배치 스크립트와 함께 - NPM과 npm.cmd ). 유닉스와 윈도우에서 실행됩니다 휴대용 스크립트를 작성하려는 경우, 당신은 바로 실행를 생성해야합니다.

@ hexacyanide의 대답은 거의 완전한 하나입니다. Windows 명령 왕자 prince.exe, prince.cmd, prince.bat하거나 왕자가 될 수에 (나는 보석이 번들로 제공하는 방법의 더 알고 있어요,하지만 NPM 쓰레기통은 쉬 스크립트와 배치 스크립트와 함께 - 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;
```

from https://stackoverflow.com/questions/20643470/execute-a-command-line-binary-with-node-js by cc-by-sa and MIT license

'NODEJS' 카테고리의 다른 글

[NODEJS] 없음 '액세스 제어 - 허용 - 원산지'- 노드 / 아파치 포트 문제 (0)	2020.09.16
[NODEJS] 거부에 전달하지 체인 약속 (0)	2020.09.16
[NODEJS] 동기 및 비동기 프로그래밍의 차이 (Node.js를 단위) 란 (0)	2020.09.16
[NODEJS] Node.js를 - 구문 에러 : 예기치 않은 토큰 가져 오기 (0)	2020.09.16
[NODEJS] NPM package.json 파일에 종속 devDependencies 및 peerDependencies의 차이점은 무엇입니까? (0)	2020.09.16

복붙노트

[NODEJS] Node.js를 사용하여 명령 줄 바이너리를 실행

Node.js를 사용하여 명령 줄 바이너리를 실행

해결법

1.Node.js를 (V8.1.4)의 경우에도 새로운 버전의 경우, 이벤트 및 호출은 유사하거나 이전 버전과 동일하지만,이 표준 새로운 언어 기능을 사용하는 것이 좋습니다 것. 예를 들면 :

2.

3.당신은 child_process.exec를 찾고 있습니다

4.버전 4부터 가장 가까운 대안은 child_process.execSync 방법입니다 :

5.

6.당신은 밀접하게 최고 응답과 유사하지만,이 의지 작업 후 동기 뭔가를합니다.

7.난 그냥 쉽게 유닉스 / 윈도우 다루는 CLI 도우미를 썼다.

8.당신은 의존성을 마음과 사용의 약속, 아이 프로세스 약속 작품 원하지 않는 경우 :

9.다음과 같이 이제 (노드 V4에서) shelljs을 사용할 수 있습니다 :

10.이 경량 NPM 패키지를 사용하여 시스템 명령을

'NODEJS' 카테고리의 다른 글

티스토리툴바