복붙노트

[NODEJS] 어떻게 Node.js를 프로그램에 명령 줄 인수를 전달합니까?

NODEJS

어떻게 Node.js를 프로그램에 명령 줄 인수를 전달합니까?

해결법

  1. 1.인수는 process.argv에 저장됩니다

    인수는 process.argv에 저장됩니다

    여기에 명령 줄 인수 처리에 노드 문서는 다음과 같습니다

    // print process.argv
process.argv.forEach(function (val, index, array) {
  console.log(index + ': ' + val);
});

    이것은 생성합니다 :

    $ node process-2.js one two=three four
0: node
1: /Users/mjr/work/node/process-2.js
2: one
3: two=three
4: four

  2. 2.일반 자바 스크립트 기능이받을 것 같은 인수를 정상화하기 위해, 나는 쉘 스크립트 내 Node.js를이 작업을 수행 :

    일반 자바 스크립트 기능이받을 것 같은 인수를 정상화하기 위해, 나는 쉘 스크립트 내 Node.js를이 작업을 수행 :

    var args = process.argv.slice(2);

    첫 번째 인수는 일반적으로 nodejs의 경로이고, 두 번째 인수는 실행중인 스크립트의 위치합니다.

  3. 3.이를위한 최신의 권리의 대답은 minimist 라이브러리를 사용합니다. 우리는 노드 낙관주의를 사용하는 데 사용하지만이 때문에 더 이상 사용되지 않습니다.

    이를위한 최신의 권리의 대답은 minimist 라이브러리를 사용합니다. 우리는 노드 낙관주의를 사용하는 데 사용하지만이 때문에 더 이상 사용되지 않습니다.

    여기가 minimist 문서에서 직접 찍은 사용하는 방법의 예는 다음과 같습니다

    var argv = require('minimist')(process.argv.slice(2));
console.dir(argv);

    -

    $ node example/parse.js -a beep -b boop
{ _: [], a: 'beep', b: 'boop' }

    -

    $ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
{ _: [ 'foo', 'bar', 'baz' ],
  x: 3,
  y: 4,
  n: 5,
  a: true,
  b: true,
  c: true,
  beep: 'boop' }

  4. 4.

    const args = process.argv;
console.log(args);

    이 반환 :

    $ node server.js one two=three four
['node', '/home/server.js', 'one', 'two=three', 'four']

    공식 문서

    Minimist : 최소한의 인수를 구문 분석하십시오.

    Commander.js : 대부분의 인수 구문 분석 모듈을 채택했다.

    야옹 : Commander.js에 라이터 대안을

    Yargs : 더 정교한 인자 분석 (무거운).

    Vorpal.js : 성인 / 인수를 구문 분석 대화 형 명령 줄 응용 프로그램.

  5. 5.낙관주의 라이브러리를 확인, 그것은 훨씬 더 손으로 명령 줄 옵션을 구문 분석보다.

    낙관주의 라이브러리를 확인, 그것은 훨씬 더 손으로 명령 줄 옵션을 구문 분석보다.

    최신 정보

    낙관적이되지 않습니다. 낙관주의의 활성 포크입니다 yargs을보십시오.

  6. 6.몇 가지 큰 여기에 대답하지만, 모두가 매우 복잡한 것 같다. 이 방법 bash는 스크립트 액세스 인수 값과 매우 유사하고 MooGoo가 지적했듯이 이미 Node.js를 기본으로 제공합니다. (그냥 Node.js를에 새로운 누군가가 이해할 수 있도록하기 위해)

    몇 가지 큰 여기에 대답하지만, 모두가 매우 복잡한 것 같다. 이 방법 bash는 스크립트 액세스 인수 값과 매우 유사하고 MooGoo가 지적했듯이 이미 Node.js를 기본으로 제공합니다. (그냥 Node.js를에 새로운 누군가가 이해할 수 있도록하기 위해)

    예:

    $ node yourscript.js banana monkey

var program_name = process.argv[0]; //value will be "node"
var script_path = process.argv[1]; //value will be "yourscript.js"
var first_value = process.argv[2]; //value will be "banana"
var second_value = process.argv[3]; //value will be "monkey"

  7. 7.옵션, 작업 및 인수를 정의하기위한 좋은 작동합니다. 그것은 또한 당신을위한 도움말 페이지를 생성합니다.

    옵션, 작업 및 인수를 정의하기위한 좋은 작동합니다. 그것은 또한 당신을위한 도움말 페이지를 생성합니다.

    당신이 콜백 방식을 좋아하는 경우에, 사용자의 입력을 얻기를위한 훌륭한 작동합니다.

    당신이 발전기 접근 방식을 좋아하는 경우에, 사용자의 입력을 얻기를위한 훌륭한 작동합니다.

  8. 8.

    function getArgs () {
    const args = {};
    process.argv
        .slice(2, process.argv.length)
        .forEach( arg => {
        // long arg
        if (arg.slice(0,2) === '--') {
            const longArg = arg.split('=');
            const longArgFlag = longArg[0].slice(2,longArg[0].length);
            const longArgValue = longArg.length > 1 ? longArg[1] : true;
            args[longArgFlag] = longArgValue;
        }
        // flags
        else if (arg[0] === '-') {
            const flags = arg.slice(1,arg.length).split('');
            flags.forEach(flag => {
            args[flag] = true;
            });
        }
    });
    return args;
}
const args = getArgs();
console.log(args);

    입력

    node test.js -D --name=Hello

    산출

    { D: true, name: 'Hello' }

    입력

    node config/build.js -lHRs --ip=$HOST --port=$PORT --env=dev

    산출

    { 
  l: true,
  H: true,
  R: true,
  s: true,
  ip: '127.0.0.1',
  port: '8080',
  env: 'dev'
}

  9. 9.NodeJS에서 구문 분석 명령 줄 인수에 가장 쉬운 방법은 표준 입출력 모듈을 사용하고 있습니다. 사소한가 아니라 다음과 같이 유닉스 getopt에 유틸리티에 의해 영감을, 그 것이다 :

    NodeJS에서 구문 분석 명령 줄 인수에 가장 쉬운 방법은 표준 입출력 모듈을 사용하고 있습니다. 사소한가 아니라 다음과 같이 유닉스 getopt에 유틸리티에 의해 영감을, 그 것이다 :

    var stdio = require('stdio');
var ops = stdio.getopt({
    'check': {key: 'c', args: 2, description: 'What this option means'},
    'map': {key: 'm', description: 'Another description'},
    'kaka': {args: 1, required: true},
    'ooo': {key: 'o'}
});

    이 명령을 사용하여 이전 코드를 실행하는 경우 :

    node <your_script.js> -c 23 45 --map -k 23 file1 file2

    그런 다음 다음과 같이 작전의 목적은 다음과 같습니다

    { check: [ '23', '45' ],
  args: [ 'file1', 'file2' ],
  map: true,
  kaka: '23' }

    당신이 원하는 그래서 당신은 그것을 사용할 수 있습니다. 예를 들어 :

    if (ops.kaka && ops.check) {
    console.log(ops.kaka + ops.check[0]);
}

    대신 -o -m의 -om 쓸 수 있도록 그룹화 옵션도 지원됩니다.

    또한, 표준 입출력 자동 도움말 / 사용법 출력을 생성 할 수 있습니다. 당신이) ops.printHelp을 (호출하면 다음을 얻을 것이다 :

    USAGE: node something.js [--check <ARG1> <ARG2>] [--kaka] [--ooo] [--map]
  -c, --check <ARG1> <ARG2>   What this option means (mandatory)
  -k, --kaka                  (mandatory)
  --map                       Another description
  -o, --ooo

    필수 옵션 (오류 메시지가 선행)으로 지정되지 않는 경우는, 이전 메시지도 표시하거나이를 mispecified 경우 (당신이 옵션에 대한 하나의 인수를 지정하는 경우, 예를 들어 그것은이 필요합니다).

    당신은 NPM을 사용하여 표준 입출력 모듈을 설치할 수 있습니다 :

    npm install stdio

  10. 10.스크립트는 myScript.js라고하고 아래 같은 인수로, 첫 번째와 마지막 이름, '숀 워싱턴'을 전달하려는 경우 :

    스크립트는 myScript.js라고하고 아래 같은 인수로, 첫 번째와 마지막 이름, '숀 워싱턴'을 전달하려는 경우 :

    node myScript.js Sean Worthington

    그런 다음 스크립트 내에서 당신은 쓰기 :

    var firstName = process.argv[2]; // Will be set to 'Sean'
var lastName = process.argv[3]; // Will be set to 'Worthington'

  11. 11.- 인수 명령 줄은 볼 가치입니다!

    - 인수 명령 줄은 볼 가치입니다!

    메인 표기 표준을 사용하여 옵션을 설정할 수 있습니다 (더 알아보기). 이 명령은 같은 값을 설정, 모두 동일합니다

    $ example --verbose --timeout=1000 --src one.js --src two.js
$ example --verbose --timeout 1000 --src one.js two.js
$ example -vt 1000 --src one.js two.js
$ example -vt 1000 one.js two.js

    값에 액세스하려면 먼저 응용 프로그램이 허용하는 옵션을 설명하는 옵션 정의 목록을 만들 수 있습니다. type 속성은 당신에게받은 값을 완벽하게 제어를 제공하는 setter 함수 (이 통과 제공된 값)입니다.

    const optionDefinitions = [
  { name: 'verbose', alias: 'v', type: Boolean },
  { name: 'src', type: String, multiple: true, defaultOption: true },
  { name: 'timeout', alias: 't', type: Number }
]

    다음 () commandLineArgs를 사용하여 옵션을 구문 분석 :

    const commandLineArgs = require('command-line-args')
const options = commandLineArgs(optionDefinitions)

    옵션은 이제 다음과 같습니다 :

    {
  src: [
    'one.js',
    'two.js'
  ],
  verbose: true,
  timeout: 1000
}

    위의 일반적인 사용 옆에, 당신은 더 많은 고급 구문 형태를 허용하도록 명령 라인 인수를 구성 할 수 있습니다.

    형태의 명령 기반 구문 (자식 스타일) :

    $ executable <command> [options]

    예를 들어.

    $ git commit --squash -m "This is my commit message"

    명령 및 형태의 하위 명령 구문 (고정 표시기 스타일) :

    $ executable <command> [options] <sub-command> [options]

    예를 들어.

    $ docker run --detached --image centos bash -c yum install -y httpd

    사용 현황 가이드 (전형적 --help가 설정되어있는 경우는 인쇄) 명령 라인 사용하여 생성 될 수있다. 아래의 예를 참조하고이를 만드는 방법 지침은 문서를 읽어보십시오.

    일반적인 사용 가이드 예.

    폴리머 - CLI 사용 가이드는 좋은 실제 예입니다.

    이 더 많이 배울 수있다, 예제 및 문서에 대한 위키를 참조하십시오.

  12. 12.다음은 명명 된 인수에 대한 내 0 출발 솔루션입니다 :

    다음은 명명 된 인수에 대한 내 0 출발 솔루션입니다 :

    const args = process.argv
    .slice(2)
    .map(arg => arg.split('='))
    .reduce((args, [value, key]) => {
        args[value] = key;
        return args;
    }, {});

console.log(args.foo)
console.log(args.fizz)

    예:

    $ node test.js foo=bar fizz=buzz
bar
buzz

    참고 : 인수가 = 포함 된 경우 당연히이 실패합니다. 이것은 매우 간단한 사용을위한 것입니다.

  13. 13.앱은 그것을 위해있다. 음, 모듈. 음, 하나 이상의, 아마 수백.

    앱은 그것을 위해있다. 음, 모듈. 음, 하나 이상의, 아마 수백.

    Yargs는 문서 읽기를 냉각하고, 재미있는 것들 중 하나입니다.

    여기 github에 / 고궁 박물원 페이지에서 예입니다 :

    #!/usr/bin/env node
var argv = require('yargs').argv;
console.log('(%d,%d)', argv.x, argv.y);
console.log(argv._);

    출력은 (는 짧고 긴, 숫자 등을 대시 등으로 옵션을 읽어) 여기에있다.

    $ ./nonopt.js -x 6.82 -y 3.35 rum
(6.82,3.35)
[ 'rum' ] 
$ ./nonopt.js "me hearties" -x 0.54 yo -y 1.12 ho
(0.54,1.12)
[ 'me hearties', 'yo', 'ho' ]

  14. 14.그것은 nconf https://github.com/flatiron/nconf 같은 것을 사용하여 중앙 집중 방식으로 구성을 관리하는 아마 좋은 생각

    그것은 nconf https://github.com/flatiron/nconf 같은 것을 사용하여 중앙 집중 방식으로 구성을 관리하는 아마 좋은 생각

    그것은 당신이 구성 파일, 환경 변수, 명령 줄 인수와 함께 작동하는 데 도움이됩니다.

  15. 15.

    const args = process.argv.slice(2).reduce((acc, arg) => {

    let [k, v = true] = arg.split('=')
    acc[k] = v
    return acc

}, {})

    이 명령 노드하는 index.js 안녕하세요 = 2 인쇄 디버그 = 거짓 MSG = 계산

    console.log(args) // { count: '2', print: true, debug: 'false', msg: 'hi' }

    우리는 변경할 수 있습니다

        let [k, v = true] = arg.split('=')
    acc[k] = v

    에 의해 (더 이상)

        let [k, v] = arg.split('=')
    acc[k] = v === undefined ? true : /true|false/.test(v) ? v === 'true' : /[\d|\.]+/.test(v) ? Number(v) : v

    자동 구문 분석 부울 및 번호에

    console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' }

  16. 16.전달, 인수를 구문 분석하는 것은 쉬운 과정이다. 노드는 노드가 호출 될 때 사용 된 인수입니다 문자열의 배열입니다 process.argv 속성을 제공합니다. 배열의 첫 번째 항목은 노드의 실행 파일이고, 두 번째 항목은 스크립트의 이름입니다.

    전달, 인수를 구문 분석하는 것은 쉬운 과정이다. 노드는 노드가 호출 될 때 사용 된 인수입니다 문자열의 배열입니다 process.argv 속성을 제공합니다. 배열의 첫 번째 항목은 노드의 실행 파일이고, 두 번째 항목은 스크립트의 이름입니다.

    당신은 인수 아래로 스크립트를 실행하는 경우

    $ node args.js arg1 arg2

    파일 : args.js

    console.log(process.argv)

    당신은 같은 배열을 얻을 것이다

     ['node','args.js','arg1','arg2']

  17. 17.

    npm install ps-grab

    node greeting.js --user Abdennour --website http://abdennoor.com

    --

    var grab=require('ps-grab');
grab('--username') // return 'Abdennour'
grab('--action') // return 'http://abdennoor.com'

    또는 뭔가 같은 :

    node vbox.js -OS redhat -VM template-12332 ;

    --

    var grab=require('ps-grab');
grab('-OS') // return 'redhat'
grab('-VM') // return 'template-12332'

  18. 18.proj.js

    proj.js

    for(var i=0;i<process.argv.length;i++){
  console.log(process.argv[i]);
}

    단말기:

    nodemon app.js "arg1" "arg2" "arg3"

    결과:

    0 'C:\\Program Files\\nodejs\\node.exe'
1 'C:\\Users\\Nouman\\Desktop\\Node\\camer nodejs\\proj.js'
2 'arg1' your first argument you passed.
3 'arg2' your second argument you passed.
4 'arg3' your third argument you passed.

    Explaination :

    0 : 당신의 maching에 node.exe의 디렉토리 (C : \ 프로그램 파일 \ nodejs \ node.exe ')

    1 : 프로젝트 파일의 디렉토리. (proj.js)

    2 : 노드에 대한 귀하의 첫 번째 인수 (ARG1)

    3 : 노드에 대한 귀하의 두 번째 인수 (ARG2)

    4 : 노드에 대한 귀하의 세 번째 인수 (에서 arg3)

    실제 인수 process.argv [2]입니다 ARGV 배열의 형태로 2 일 지수를 시작합니다.

  19. 19.당신은 system.args을 사용하여 명령 행 인수에 도달 할 수 있습니다. 내가 이름으로 할 하나 얻을 수 있도록 그리고 난, 객체로 해석 인수에 아래의 솔루션을 사용합니다.

    당신은 system.args을 사용하여 명령 행 인수에 도달 할 수 있습니다. 내가 이름으로 할 하나 얻을 수 있도록 그리고 난, 객체로 해석 인수에 아래의 솔루션을 사용합니다.

    var system = require('system');

var args = {};
system.args.map(function(x){return x.split("=")})
    .map(function(y){args[y[0]]=y[1]});

    지금 당신은 인수의 인덱스를 알 필요가 없습니다. args.whatever처럼 사용

  20. 20.당신은 모든 인수를 구문 분석하고 존재하는 경우를 확인할 수 있습니다.

    당신은 모든 인수를 구문 분석하고 존재하는 경우를 확인할 수 있습니다.

    파일을 구문 분석 - CLI-arguments.js :

    module.exports = function(requiredArguments){
    var arguments = {};

    for (var index = 0; index < process.argv.length; index++) {
        var re = new RegExp('--([A-Za-z0-9_]+)=([A/-Za-z0-9_]+)'),
            matches = re.exec(process.argv[index]);

        if(matches !== null) {
            arguments[matches[1]] = matches[2];
        }
    }

    for (var index = 0; index < requiredArguments.length; index++) {
        if (arguments[requiredArguments[index]] === undefined) {
            throw(requiredArguments[index] + ' not defined. Please add the argument with --' + requiredArguments[index]);
        }
    }

    return arguments;
}

    단지보다 수행

    var arguments = require('./parse-cli-arguments')(['foo', 'bar', 'xpto']);

  21. 21.인수를 전달하는 것은 용이하고,이를 수신하는 것은 기본적으로 노드가 사방에서 접근하게 process.argv 배열을 읽기의 문제이다. 그러나 당신은 당신이 그것을 해석하는 스크립트에 조각을해야합니다, 그래서 키 / 값 쌍으로 그들을 읽고 싶어 확신합니다.

    인수를 전달하는 것은 용이하고,이를 수신하는 것은 기본적으로 노드가 사방에서 접근하게 process.argv 배열을 읽기의 문제이다. 그러나 당신은 당신이 그것을 해석하는 스크립트에 조각을해야합니다, 그래서 키 / 값 쌍으로 그들을 읽고 싶어 확신합니다.

    조셉 Merdrignac 감소하여 아름다운 하나를 게시하지만, 그것은 키 = 값 구문 대신 -k 값과 --key 값에 의존했다. 나는 그 두 번째 표준을 사용하는 것이 훨씬 더 추악한과 이상을 재 작성하고 논평으로 적합하지 않기 때문에 내가 대답으로 게시합니다. 그러나 작업을 끝내야한다.

       const args = process.argv.slice(2).reduce((acc,arg,cur,arr)=>{
     if(arg.match(/^--/)){
       acc[arg.substring(2)] = true
       acc['_lastkey'] = arg.substring(2)
     } else
     if(arg.match(/^-[^-]/)){
       for(key of arg.substring(1).split('')){
         acc[key] = true
         acc['_lastkey'] = key
       }
     } else
       if(acc['_lastkey']){
         acc[acc['_lastkey']] = arg
         delete acc['_lastkey']
       } else
         acc[arg] = true
     if(cur==arr.length-1)
       delete acc['_lastkey']
     return acc
   },{})

    이 코드 명령 노드 script.js 알파 베타 - 찰리 델타 --echo 폭스 트롯는 당신에게 다음과 같은 객체를 줄 것이다

    
args = {
 "alpha":true,
 "beta":true,
 "c":true,
 "h":true,
 "a":true,
 "r":true
 "l":true,
 "i":true,
 "e":"delta",
 "echo":"foxtrot"
}

  22. 22.당신은 바닐라 JS / ES6에서이 작업을 수행하려면 다음과 같은 솔루션을 사용할 수 있습니다

    당신은 바닐라 JS / ES6에서이 작업을 수행하려면 다음과 같은 솔루션을 사용할 수 있습니다

    단지 NodeJS> 6 일

    const args = process.argv
  .slice(2)
  .map((val, i)=>{
    let object = {};
    let [regexForProp, regexForVal] = (() => [new RegExp('^(.+?)='), new RegExp('\=(.*)')] )();
    let [prop, value] = (() => [regexForProp.exec(val), regexForVal.exec(val)] )();
    if(!prop){
      object[val] = true;
      return object;
    } else {
      object[prop[1]] = value[1] ;
      return object
    }
  })
  .reduce((obj, item) => {
    let prop = Object.keys(item)[0];
    obj[prop] = item[prop];
    return obj;
  }, {});

    그리고이 명령

    node index.js host=http://google.com port=8080 production

    다음과 같은 결과를 생성합니다

    console.log(args);//{ host:'http://google.com',port:'8080',production:true }
console.log(args.host);//http://google.com
console.log(args.port);//8080
console.log(args.production);//true

    추신. 지도의 코드를 수정하고 기능을 줄 이세요 당신은 더 우아한 솔루션, 덕분에 찾을 경우)

  23. 23.위 답변은 완벽, 누군가가 이미 yargs을 제안하고 있지만, 패키지를 사용하는 것은 정말 쉽습니다. 이건 정말 쉬운 명령 줄에 인수를 전달하게하는 좋은 패키지입니다.

    위 답변은 완벽, 누군가가 이미 yargs을 제안하고 있지만, 패키지를 사용하는 것은 정말 쉽습니다. 이건 정말 쉬운 명령 줄에 인수를 전달하게하는 좋은 패키지입니다.

    npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);

    추가 정보를 원하시면 https://yargs.js.org/를 방문하십시오.

  24. 24.Node.js를에서 인수를 검색하는 가장 간단한 방법은 process.argv 배열을 통해입니다. 이것은 당신이 그것을 사용하기 위해 추가 라이브러리를 가져 오지 않고 사용할 수있는 전역 개체입니다. 당신은 단순히 우리가 이전에 보여 주었다 단지처럼 Node.js를 응용 프로그램에 인수를 전달해야하고, 이러한 인수는 process.argv 배열을 통해 응용 프로그램 내에서 액세스 할 수 있습니다.

    Node.js를에서 인수를 검색하는 가장 간단한 방법은 process.argv 배열을 통해입니다. 이것은 당신이 그것을 사용하기 위해 추가 라이브러리를 가져 오지 않고 사용할 수있는 전역 개체입니다. 당신은 단순히 우리가 이전에 보여 주었다 단지처럼 Node.js를 응용 프로그램에 인수를 전달해야하고, 이러한 인수는 process.argv 배열을 통해 응용 프로그램 내에서 액세스 할 수 있습니다.

    process.argv 배열의 첫 번째 요소는 항상 노드의 실행 파일을 가리키는 파일 시스템 경로가 될 것입니다. 두 번째 요소는 실행중인 자바 스크립트 파일의 이름입니다. 그리고 세 번째 요소는 실제로 사용자에 의해 전달 된 첫 번째 인수입니다.

    'use strict';

for (let j = 0; j < process.argv.length; j++) {  
    console.log(j + ' -> ' + (process.argv[j]));
}

    이 스크립트의 수행 모두 process.argv 배열을 반복하고 그 인덱스에 저장된 요소와 함께 인덱스를 출력한다. 그것은 만약 당신이 이제까지 질문 무엇을 인수 당신이있는 거 수신, 어떤 질서를 디버깅하기 위해 매우 유용합니다.

    또한 commnadline 인수 작업을위한 yargs 같은 라이브러리를 사용할 수 있습니다.

  25. 25.어떤 라이브러리와 타이프 라이터 솔루션 :

    어떤 라이브러리와 타이프 라이터 솔루션 :

    interface IParams {
  [key: string]: string
}

function parseCliParams(): IParams {
  const args: IParams = {};
  const rawArgs = process.argv.slice(2, process.argv.length);
  rawArgs.forEach((arg: string, index) => {
    // Long arguments with '--' flags:
    if (arg.slice(0, 2).includes('--')) {
      const longArgKey = arg.slice(2, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: --connection connection_name
      args[longArgKey] = longArgValue;
    }
    // Shot arguments with '-' flags:
    else if (arg.slice(0, 1).includes('-')) {
      const longArgKey = arg.slice(1, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: -c connection_name
      args[longArgKey] = longArgValue;
    }
  });
  return args;
}

const params = parseCliParams();
console.log('params: ', params);

    입력 : TS-노드하는 index.js -p PARAM --parameter 매개 변수

    출력 : {P : 'PARAM'매개 변수 '매개 변수'}

  26. 26.표준 입력에 기초하여 인자를 파싱 (--key = 값)

    표준 입력에 기초하여 인자를 파싱 (--key = 값)

    const argv = (() => {
    const arguments = {};
    process.argv.slice(2).map( (element) => {
        const matches = element.match( '--([a-zA-Z0-9]+)=(.*)');
        if ( matches ){
            arguments[matches[1]] = matches[2]
                .replace(/^['"]/, '').replace(/['"]$/, '');
        }
    });
    return arguments;
})();

    명령 예

    node app.js --name=stackoverflow --id=10 another-argument --text="Hello World"

    ARGV의 결과 : CONSOLE.LOG (변수는 argv를)

    {
    name: "stackoverflow",
    id: "10",
    text: "Hello World"
}

  27. 27.process.argv는 기본적으로 노드 JS에서 지원되는 명령 행 인수를 캡처, 당신의 친구입니다. 예를 들어 아래를 참조하십시오 :

    process.argv는 기본적으로 노드 JS에서 지원되는 명령 행 인수를 캡처, 당신의 친구입니다. 예를 들어 아래를 참조하십시오 :

    process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
})

  28. 28.노드 문서에 명시된 바와 같이 Node.js를 프로세스가 시작되었을 때 process.argv 속성 반환 명령 줄 인수를 포함하는 배열을 통과시켰다.

    노드 문서에 명시된 바와 같이 Node.js를 프로세스가 시작되었을 때 process.argv 속성 반환 명령 줄 인수를 포함하는 배열을 통과시켰다.

    예를 들어, 프로세스 args.js에 대해 다음 스크립트를 가정 :

    // print process.argv
process.argv.forEach((val, index) => {
   console.log(`${index}: ${val}`);
});

    Node.js를 프로세스로 시작 :

     $ node process-args.js one two=three four

    출력을 생성합니다 :

    0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four

  29. 29.대부분의 사람들은 좋은 답을 주었다. 또한 여기에 뭔가를 기여하고 싶습니다. 나는 응용 프로그램을 시작하는 동안 우리가 통과하는 모든 명령 행 인수를 통해 반복 lodash 라이브러리를 사용하여 답을 제공하고있다 :

    대부분의 사람들은 좋은 답을 주었다. 또한 여기에 뭔가를 기여하고 싶습니다. 나는 응용 프로그램을 시작하는 동안 우리가 통과하는 모든 명령 행 인수를 통해 반복 lodash 라이브러리를 사용하여 답을 제공하고있다 :

    // Lodash library
const _ = require('lodash');

// Function that goes through each CommandLine Arguments and prints it to the console.
const runApp = () => {
    _.map(process.argv, (arg) => {
        console.log(arg);
    });
};

// Calling the function.
runApp();

    위의 코드를 실행하려면 단지 명령을 다음 실행 :

    npm install
node index.js xyz abc 123 456

    그 결과는 다음과 같습니다

    xyz 
abc 
123
456

  30. 30.Node.js를 프로그램에 명령 줄 인수를 전달하는 가장 좋은 방법은 명령 줄 인터페이스 (CLI)를 사용하는 것입니다

    Node.js를 프로그램에 명령 줄 인수를 전달하는 가장 좋은 방법은 명령 줄 인터페이스 (CLI)를 사용하는 것입니다

    당신이 사용할 수있는 nodejs-CLI라는 멋진 NPM 모듈이있다.

    당신은 당신이 그것을 확인 싶으면 내 Github에서에 하나를 가지고 종속되지 하나 만들려면, 실제로 매우 간단하고 사용하기 쉬운이다, 여기를 클릭하십시오.

    31. from https://stackoverflow.com/questions/4351521/how-do-i-pass-command-line-arguments-to-a-node-js-program by cc-by-sa and MIT license

'NODEJS' 카테고리의 다른 글

[NODEJS] 어떻게 Node.js를에 오류 ECONNRESET을 디버깅 할 수 있습니까?  (0) 2020.09.16
[NODEJS] 어떻게 (타사 라이브러리를 사용하지 않고) Node.js를 가진 파일을 다운로드?  (0) 2020.09.16
[NODEJS] 어떻게 '[오브젝트]') Node.js를의 CONSOLE.LOG (에 전체 개체를 얻을보다는 할 수 있습니까?  (0) 2020.09.16
[NODEJS] Express를 사용 NodeJS 서버에서 파일을 다운로드  (0) 2020.09.16
[NODEJS] 어떻게 NPM의 ERR "NPM 오류를 해결하기 위해! 코드 ELIFECYCLE "  (0) 2020.09.16
,

티스토리툴바