Вопрос: Как передать аргументы командной строки программе Node.js?


У меня есть веб-сервер, написанный на Node.js и я хотел бы запустить с определенной папкой. Я не уверен, как обращаться к аргументам в JavaScript. Я запускаю узел следующим образом:

$ node server.js folder

Вот server.jsэто мой код сервера. Справка Node.js говорит, что это возможно:

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

Как мне получить доступ к этим аргументам в JavaScript? Почему-то я не смог найти эту информацию в Интернете.


1726


источник


Ответы:


Стандартный метод (без библиотеки)

Аргументы хранятся в process.argv

Вот узел docs при обработке аргументов командной строки:

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

2286



Чтобы нормализовать аргументы, подобные обычной функции javascript, я получаю это в своих сценариях shell.js:

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

Обратите внимание, что первым аргументом arg обычно является путь к nodejs, а второй arg - местоположение исполняемого вами скрипта.


458



Современный правильно ответьте на это, чтобы использовать 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' }

227



2018 ответ на основе текущих тенденций в дикой природе:


Анализ валидного javascript валидации:

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 : Самый принятый модуль для разбора аргументов.

мяу : Более легкая альтернатива Commander.js

Yargs : Более сложный парсинг аргументов (тяжелый).

Vorpal.js : Зрелые / интерактивные приложения командной строки с разбором аргументов.


185



Оптимист (узел-оптимист)

Проверять, выписываться библиотека оптимистов , это намного лучше, чем вручную разбирать параметры командной строки.

Обновить

Оптимист устарел. Пытаться yargs которая является активной вилкой оптимиста.


107



Commander.js

Works great for defining your options, actions, and arguments. It also generates the help pages for you.

Promptly

Works great for getting input from the user, if you like the callback approach.

Co-Prompt

Works great for getting input from the user, if you like the generator approach.


65



Several great answers here, but it all seems very complex. This is very similar to how bash scripts access argument values and it's already provided standard with node.js as MooGoo pointed out. (Just to make it understandable to somebody that's new to node.js)

Example:

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

65



Stdio Library

The easiest way to parse command-line arguments in NodeJS is using the stdio module. Inspired by UNIX getopt utility, it is as trivial as follows:

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, mandatory: true},
    'ooo': {key: 'o'}
});

If you run the previous code with this command:

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

Then ops object will be as follows:

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

So you can use it as you want. For instance:

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

Grouped options are also supported, so you can write -om instead of -o -m.

Furthermore, stdio can generate a help/usage output automatically. If you call ops.printHelp() you'll get the following:

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

The previous message is shown also if a mandatory option is not given (preceded by the error message) or if it is mispecified (for instance, if you specify a single arg for an option and it needs 2).

You can install stdio module using NPM:

npm install stdio

35



If your script is called myScript.js and you want to pass the first and last name, 'Sean Worthington', as arguments like below:

node myScript.js Sean Worthington

Then within your script you write:

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

26



command-line-args is worth a look!

You can set options using the main notation standards (learn more). These commands are all equivalent, setting the same values:

$ 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

To access the values, first create a list of option definitions describing the options your application accepts. The type property is a setter function (the value supplied is passed through this), giving you full control over the value received.

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

Next, parse the options using commandLineArgs():

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

options now looks like this:

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

Advanced usage

Beside the above typical usage, you can configure command-line-args to accept more advanced syntax forms.

Command-based syntax (git style) in the form:

$ executable <command> [options]

For example.

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

Command and sub-command syntax (docker style) in the form:

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

For example.

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

Usage guide generation

A usage guide (typically printed when --help is set) can be generated using command-line-usage. See the examples below and read the documentation for instructions how to create them.

A typical usage guide example.

usage

The polymer-cli usage guide is a good real-life example.

usage

Further Reading

There is plenty more to learn, please see the wiki for examples and documentation.


19



There's an app for that. Well, module. Well, more than one, probably hundreds.

Yargs is one of the fun ones, its docs are cool to read.

Here's an example from the github/npm page:

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

Output is here (it reads options with dashes etc, short and long, numeric etc).

$ ./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' ]

16



It's probably a good idea to manage your configuration in a centralized manner using something like nconf https://github.com/flatiron/nconf

It helps you work with configuration files, environment variables, command-line arguments.


7