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

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

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

process.argv - это массив, содержащий аргументы командной строки. Первый элемент будет «узел», второй элемент будет именем файла 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

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

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

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

Актуальный правильный ответ для этого - использовать библиотеку 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 года, основанный на текущих тенденциях в дикой природе:

Ванильный аргумент JavaScript синтаксический анализ:

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

Это возвращает:

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

Официальные документы

Наиболее используемые пакеты NPM для анализа аргументов:

Минимист: для минимального анализа аргументов.

Commander.js: наиболее принятый модуль для анализа аргументов.

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

Яргс: более сложный анализ аргументов (тяжелый).

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

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

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

Обновить

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

Несколько отличных ответов здесь, но все это кажется очень сложным. Это очень похоже на то, как сценарии bash получают доступ к значениям аргументов, и уже снабжены стандартом с node.js, как указал MooGoo. (Просто чтобы сделать это понятным для кого-то, кто новичок в 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

Отлично подходит для определения ваших вариантов, действий и аргументов. Он также генерирует страницы справки для вас.

Быстро

Отлично подходит для получения информации от пользователя, если вам нравится подход обратного вызова.

Co-Prompt

Отлично подходит для получения информации от пользователя, если вам нравится подход генератора.

Библиотека Stdio

Самый простой способ проанализировать аргументы командной строки в 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, mandatory: true},
    'ooo': {key: 'o'}
});

Если вы запустите предыдущий код с этой командой:

node  -c 23 45 --map -k 23 file1 file2

Тогда объект ops будет следующим:

{{{797222}}}

Таким образом, вы можете использовать его как хотите. Например:

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

Также поддерживаются сгруппированные параметры, поэтому вы можете написать -om вместо -o -m.

Кроме того, stdio может автоматически генерировать вывод справки / использования. Если вы позвоните в ops.printHelp (), вы получите следующее:

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

Предыдущее сообщение отображается также, если не указана обязательная опция (предшествует сообщение об ошибке) или если она неверно определена (например, если вы указываете один аргумент для опции и для нее требуется 2).

Вы можете установить модуль stdio, используя NPM:

npm install stdio

Если ваш скрипт называется 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'

Нет Libs с флагами, отформатированными в простой объект

function getArgs () {
    const args = {{{}}} ;
    process.argv
        .slice (2, process.argv.length)
        .forEach (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 ;
        }
        // флаги
        иначе if (arg [0] === '-') {
            const flags = arg.slice (1, arg.length) .split ('') ;
            flags.forEach (флаг = > {
            args [флаг] = true ;
            });
        }
    });
    вернуть аргументы ;
}
const args = getArgs () ;
consol.log (args);

Примеры

Просто

ввод

node test.js -D --name = Hello

вывод

{D: true, name: 'Hello'}

Реальный мир

ввод

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

вывод

{
   Я правда
  H: правда,
  R: правда,
  с: правда,
  ip: '127.0.0.1',
  порт: '8080',
  env: 'dev'
}

командная строка-арги стоит посмотреть!

Вы можете установить параметры, используя основные стандарты обозначений (узнать больше). Все эти команды эквивалентны, устанавливая одинаковые значения:

$ 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 является функцией сеттера (поставляемое значение передается через это), давая вам полный контроль над полученным значением.

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
}

Расширенное использование

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

[Синтаксис на основе команд](https://github.com/75lb/command-line-args/wiki/Implement-command-parsing- (git-style)) (git style) в форме:

$ executable  [options]

Например.

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

[Синтаксис команд и подкоманд](https://github.com/75lb/command-line-args/wiki/Implement-multiple-command-parsing- (стиль докера)) (стиль докера) в форме: ,

$ executable  [options]  [options]

Например.

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

Руководство по использованию поколения

Руководство по использованию (обычно печатается при установке --help) можно создать с помощью командная строка-использование. См. Примеры ниже и прочитайте документацию для получения инструкций по их созданию.

Типичный пример руководства по использованию.

использование! Руководство по использованию polymer-cli является хорошим примером в реальной жизни.

использование!

Дальнейшее чтение

Есть еще много чего узнать, см. Вики для примеров и документации.

Для этого есть приложение. Ну, модуль. Ну, больше, чем один, наверное, сотни.

Яргс - один из самых забавных, его документы круто читать.

Вот пример со страницы 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

Примечание. Естественно, это не удастся, если аргумент содержит =. Это только для очень простого использования.

без каких-либо либрарий: с использованием 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

автоматически анализировать Boolean & Число

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

Вероятно, это хорошая идея - управлять своей конфигурацией централизованно, используя что-то вроде nconf https://github.com/flatiron/nconf

Это поможет вам работать с файлами конфигурации, переменными среды, аргументами командной строки.

Передача, утверждение аргументов - это простой процесс. Node предоставляет вам свойство process.argv, которое представляет собой массив строк, которые являются аргументами, которые использовались при вызове 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

Вы можете достичь аргументов командной строки, используя 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.whwhat

Примечание: для использования вы должны использовать именованные аргументы типа 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']);