Node.js로 작성된 웹 서버가 있으며 특정 폴더로 시작하고 싶습니다. JavaScript에서 인수에 액세스하는 방법을 잘 모르겠습니다. 다음과 같이 노드를 실행 중입니다.

$ node server.js folder

여기 server.js내 서버 코드가 있습니다. Node.js 도움말은 이것이 가능하다고 말합니다.

$ node -h
Usage: node [options] script.js [arguments]

JavaScript에서 이러한 인수에 어떻게 액세스합니까? 어떻게 든 웹 에서이 정보를 찾을 수 없었습니다.

표준 방법 (라이브러리 없음)

인수는 process.argv

다음은 명령 행 인수 처리에 대한 노드 문서입니다.

process.argv명령 행 인수를 포함하는 배열입니다. 첫 번째 요소는 'node'이고 두 번째 요소는 JavaScript 파일의 이름입니다. 다음 요소는 추가 명령 줄 인수입니다.

// 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

일반 자바 스크립트 함수가받는 것처럼 인수를 정규화하려면 node.js 쉘 스크립트 에서이 작업을 수행하십시오.

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

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

업 - - 날짜 우측의 이을에 대한 대답은 사용하는 minimist의 라이브러리를. 우리는 node-optimist 를 사용 했지만 그 이후에는 더 이상 사용되지 않습니다.

다음은 미니멀리스트 문서에서 직접 사용하는 방법의 예입니다.

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' }

2018 년은 야생의 현재 추세를 기반으로 답변합니다.

바닐라 자바 ​​스크립트 인수 파싱 :

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

이것은 다음을 반환합니다.

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

공식 문서

인수 구문 분석에 가장 많이 사용 된 NPM 패키지 :

Minimist : 최소한의 인수 분석.

Commander.js : 인수 구문 분석에 가장 많이 채택 된 모듈.

Meow : Commander.js에 대한 더 가벼운 대안

Yargs :보다 복잡한 인수 구문 분석 (무거운).

Vorpal.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"

Commander.js

옵션, 조치 및 인수를 정의하는 데 효과적입니다. 또한 도움말 페이지를 생성합니다.

즉시

콜백 방식이 마음에 들면 사용자의 입력을받는 데 효과적입니다.

공동 프롬프트

생성기 방식이 마음에 들면 사용자의 입력을받는 데 효과적입니다.

간단한 객체로 포맷 된 플래그가있는 립 없음

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'
}

스테 디오 도서관

NodeJS에서 명령 행 인수를 구문 분석하는 가장 쉬운 방법은 stdio 모듈을 사용하는 것 입니다. UNIX 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

그러면 ops객체는 다음과 같습니다.

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

따라서 원하는대로 사용할 수 있습니다. 예를 들어 :

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

그룹화 된 옵션도 지원되므로 -om대신에 쓸 수 있습니다 -o -m.

또한 stdio도움말 / 사용 출력을 자동으로 생성 할 수 있습니다. 전화 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

이전 메시지는 필수 옵션이 제공되지 않거나 (오류 메시지가 선행) 옵션이 지정되지 않은 경우 (예 : 옵션에 단일 arg를 지정하고 2가 필요한 경우)도 표시됩니다.

NPM을 사용하여 stdio 모듈을 설치할 수 있습니다 .

npm install stdio

스크립트 이름이 myScript.js이고 이름과 성 'Sean Worthington'을 아래와 같은 인수로 전달하려는 경우 :

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'

커맨드 라인 인수 는 가치가 있습니다!

기본 표기법을 사용하여 옵션을 설정할 수 있습니다 ( 자세히 알아보기 ). 이 명령은 모두 동일하며 동일한 값을 설정합니다.

$ 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)

options 이제 다음과 같이 보입니다 :

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

고급 사용법

위의 일반적인 사용법 외에도 고급 구문 형식을 허용하도록 명령 줄 인수를 구성 할 수 있습니다.

다음 형식의 명령 기반 구문 (git 스타일) :

$ 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 사용 가이드는 좋은 실제 예입니다.

추가 자료

더 많은 것을 배울 수 있습니다. 예제와 문서 는 위키 를 참조하십시오 .

이를위한 앱이 있습니다. 글쎄, 모듈. 음, 하나 이상, 아마도 수백 개.

Yargs 는 재미있는 것들 중 하나이며, 그 문서는 읽기에 좋습니다.

다음은 github / npm 페이지의 예입니다.

#!/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' ]

명명 된 인수에 대한 0-dep 솔루션은 다음과 같습니다.

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

참고 : 인수에가 포함되어 있으면 당연히 실패합니다 =. 이것은 매우 간단한 사용법입니다.

nconf https://github.com/flatiron/nconf 와 같은 것을 사용하여 중앙 집중식으로 구성을 관리하는 것이 좋습니다.

구성 파일, 환경 변수, 명령 행 인수로 작업하는 데 도움이됩니다.

라이브러리없이 : Array.prototype.reduce () 사용

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

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

}, {})

이 명령 node index.js count=2 print debug=false msg=hi

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' }

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

아래의 인수로 스크립트를 실행하면

$ node args.js arg1 arg2

파일 : args.js

console.log(process.argv)

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

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

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'

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.

설명 :

0 : maching의 node.exe 디렉토리 (C : \ Program Files \ nodejs \ node.exe ')

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

2 : 노드에 대한 첫 번째 인수 (arg1)

3 : 노드에 대한 두 번째 인수 (arg2)

4 : 노드에 대한 세 번째 인수 (arg3)

실제 인수 2nd는 argv배열의 인덱스 색인을 시작합니다 process.argv[2].

을 사용하여 명령 행 인수에 도달 할 수 있습니다 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

참고 : file.js x=1 y=2이 솔루션을 사용하는 것처럼 명명 된 인수 를 사용해야합니다.

모든 인수를 구문 분석하고 존재하는지 확인할 수 있습니다.

파일 : parse-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']);

도서관없이

바닐라 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

추신 : 더 우아한 솔루션을 찾으면 맵에서 코드를 수정하고 기능을 줄이십시오.

위의 답변은 완벽하지만 누군가가 이미 yargs를 제안했지만 패키지 사용은 정말 쉽습니다. 이것은 명령 행에 인수를 전달하는 것을 매우 쉽게 만드는 멋진 패키지입니다.

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

자세한 내용은 https://yargs.js.org/ 를 방문 하십시오 .

인수를 전달하는 것은 쉬우 며, 인수를받는 것은 프로세스를 읽는 것의 문제입니다. 그러나 이들을 키 / 값 쌍으로 읽으려고하므로이를 해석하려면 스크립트를 작성해야합니다.

Joseph Merdrignac은 reduce를 사용하여 아름다운 것을 게시했지만 및 key=value대신 구문에 의존했습니다 . 나는 그 두 번째 표준을 사용하기 위해 훨씬 더 길고 더 오래 썼다. 그러나 작업이 완료됩니다.-k value--key value

   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
   },{})

이 코드로 명령 node script.js alpha beta -charlie delta --echo foxtrot은 다음과 같은 객체를 제공합니다.

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

Node.js에서 인수를 검색하는 가장 간단한 방법은 process.argv 배열을 사용하는 것입니다. 추가 라이브러리를 가져 오지 않고 사용할 수있는 전역 객체입니다. 앞에서 보여준 것처럼 Node.js 애플리케이션에 인수를 전달하면됩니다. 이러한 인수는 process.argv 배열을 통해 애플리케이션 내에서 액세스 할 수 있습니다.

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

'use strict';

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

이 스크립트는 process.argv 배열을 반복하고 인덱스에 저장된 요소와 함께 인덱스를 인쇄합니다. 어떤 인수를 어떤 순서로 받는지 궁금한 경우 디버깅에 매우 유용합니다.

commnadline 인수로 작업하기 위해 yargs와 같은 라이브러리를 사용할 수도 있습니다.

라이브러리가없는 TypeScript 솔루션 :

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-node index.js -p param --parameter parameter

산출: { p: 'param ', parameter: 'parameter' }

process.argvNode JS에서 기본적으로 지원되는 명령 행 인수 캡처는 친구입니다. 아래 예를 참조하십시오. :

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

node docs에 명시된대로 process.argv 속성은 Node.js 프로세스가 시작될 때 전달 된 명령 줄 인수를 포함하는 배열을 반환합니다.

예를 들어 process-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

대부분의 사람들이 좋은 대답을했습니다. 나는 또한 여기에 뭔가를 기부하고 싶습니다. 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

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

사용할 수있는 nodejs-cli 라는 멋진 npm 모듈 이 있습니다.

의존성이없는 것을 만들려면 Github에서 하나를 확인하고 싶습니다. 실제로 사용하기 쉽고 간단 합니다 . 여기를 클릭 하십시오 .

ES6 스타일 비 종속 솔루션 :

const longArgs = arg => {
    const [ key, value ] = arg.split('=');
    return { [key.slice(2)]: value || true }
};

const flags = arg => [...arg.slice(1)].reduce((flagObj, f) => ({ ...flagObj, [f]: true }), {});


const args = () =>
    process.argv
        .slice(2)
        .reduce((args, arg) => ({
            ...args,
            ...((arg.startsWith('--') && longArgs(arg)) || (arg[0] === '-' && flags(arg)))
        }), {});

console.log(args());