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

2418

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

$ node server.js folder

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

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

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

milkplus
источник

Ответы:

3049

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

Аргументы хранятся в 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
MooGoo
источник
7
Что я должен набрать в командной строке, чтобы запустить скрипт node.js с аргументами командной строки?
Андерсон Грин
8
ОБНОВЛЕНИЕ: я нашел ответ на вопрос выше. stackoverflow.com/questions/12925802/…
Андерсон Грин
2
Минимист - отличный и простой анализатор аргументов
Гильерме Нагатомо
4
Вы также можете получить доступ к одному аргументу, когда знаете его позицию: process.argv[n]где nнаходится индекс,
начинающийся
6
2-й элемент (process.argv [1]) может быть или не быть файлом js. Синтаксис команды узла - node [options] [ -e script | script.js ] [arguments]или node debug script.js [arguments]. например: node --harmony script.js balalaили node --no-deprecation --enable-ssl2 script.js balala, мы можем использовать process.execArgv с process.argv
cuixiping
680

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

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

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

Мовис Ледфорд
источник
19
Просто обратите внимание, что я написал этот ответ 4 года назад, и код, который я выполняю, все еще работает на 100% сегодня. Все еще в курсе последних версий узлов и ноль проблем: это всего лишь простой сценарий оболочки, ребята. Не является частью большого глобального объекта, полного библиотек JS. Я все еще поддерживаю мой ответ сегодня. Я дам еще одно обновление еще через 4 года.
Mauvis Ledford
36
@cuixiping , но execArgvэто не в argvтак что 2 достаточно
Tommi Kyntola
7
Посмотрев историю изменений этого ответа, я хотел бы уделить немного времени, чтобы посочувствовать @MauvisLedford. Нет ничего более раздражающего, чем нежелательные правки вашего кода во имя личных предпочтений (без измеримых преимуществ для загрузки). Кому это делает: отбросить.
Джонатан
7
Привет @MauvisLedford это было еще четыре года. Я хотел бы обновление!
Эндрю Лориен
13
НЕprocess.argv.splice(process.execArgv.length + 2) : для команды node --harmony script.js --version, process.argvэто ['/usr/local/bin/node', 'script.js', '--version']. Флаги на nodeкоторые НЕ включены в process.argv!
Константин Ван
361

Уточненное право ответ на это его использовать 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' }
real_ate
источник
32
На самом деле, это решение более полезно для разработки инструмента командной строки с большим количеством флагов и аргументов, и должно быть одобрено больше IMHO.
JK ABC
2
Имо, это более простая альтернатива npmjs.com/package/command-line-args
klodoma
5
@JKABC Я бы не назвал это наиболее правильным ответом, так как ОП просто запрашивает тривиальную информацию командной строки. Но я согласен с тем, что и minimist, и аргументы командной строки очень полезны, если вы планируете расширить свой CLI.
Юстус Ромейн
2
Интересно, почему '-n5' не выдает 'n5: true' - это имело бы смысл для меня.
Макс Уотерман
8
@MaxWaterman: потому что опции, начинающиеся с одной черты, допускаются только для одного символа. Все, что следует за одной опцией char, берется в качестве аргумента для этой опции (без пробела). Запуск опции с двумя тире (т. Е. --N5) должен привести к 'n5: true'. Это довольно стандартное поведение для большинства инструментов командной строки Unix (но, к сожалению, не все).
Менно Смитс
314

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

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

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

dthree
источник
77
"$ npm install -g yargs" дал 1,9 МБ кода JavaScript. Когда закончится это безумие, когда библиотеке анализатора argv понадобится два мегабайта кода? Увеличена поверхность атаки,
потеря
9
Yargs - более крупный инструмент, который также анализирует аргументы командной строки. Никакого безумия, просто недостаток информации. Если вы хотите что-то более легкое, используйте сырой JS, Meow или Minimist.
dthree
1
«$ npm i yargs» -> 800 КБ здесь, я думаю, владельцы пакетов наконец-то научились игнорировать ненужные файлы. Во всяком случае, все еще большой для глупых проектов, но маленький, когда вам нужна надежность, а в более крупных проектах у вас уже есть зависимости ..
Andre Figueiredo
3
Я создал пакет, названный wily-cli , с целью создания более мощного, более настраиваемого и более простого в использовании инструмента, чем перечисленные громкие имена. Для тех из вас, кто заинтересован, это всего лишь 94,6 КБ после установки
Jason
1
vscode import-cost говорит мне, что ярги (159,2 КБ) теперь на самом деле легче мяу (180,2 КБ). Минимист все еще бьет их в 3.4K!
Шивам Трипати
124

Оптимист (нод-оптимист)

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

Обновить

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

Gor
источник
18
+1 за ссылку. Существует довольно длинный список анализаторов параметров командной строки на github.com/joyent/node/wiki/modules#wiki-parsers-commandline
Thilo
7
Минимист - еще один преемник ныне обескураженного оптимиста. Это «мужество анализатора аргументов оптимиста без всяких причудливых украшений». 23 миллиона загрузок за последний месяц (по состоянию на 12/2015).
аап
96

Несколько отличных ответов здесь, но все это кажется очень сложным. Это очень похоже на то, как 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"
Пол ван Яарсвельд
источник
80

Commander.js

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

быстро

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

Co-Prompt

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

balupton
источник
26
@ Эван Кэрролл, пожалуйста, не редактируйте мой ответ, чтобы рекламировать библиотеку. Я не использую stackoverflow.com/posts/7483600/revisions, особенно из-за отсутствующей функции, которую вы ищите, такие мнения следует сохранять для комментариев или запросов на авторы модуля, а не редактируют ответы других людей.
Балуптон
Commander.js действительно помог мне. Другие библиотеки не будут работать с компилятором nexe, но эта делает свое дело. Если вы хотите получить аргументы при использовании nexe, обязательно передайте -f компилятору nexe.
pierce.jason
60

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

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'
}
Майкл Уорнер
источник
1
Поскольку некоторые флаги имеют длинную форму, вы можете объяснить это. Вместо того, чтобы = longArg[1]вы могли написать, = longArg.length > 1 ? longArg[1] : true;Это позволило бы вам передать этот тип аргумента:node config/build.js --flag1 --flag2
Тралстон
Мне это нравится. Это сделало линию немного длинной, поэтому я разорвал ее. Спасибо, что рассказали мне об этом.
Майкл Уорнер
54

Библиотека Стдио

Самым простым способом анализа аргументов командной строки в NodeJS является использование модуля stdio . Вдохновленный getoptутилитой UNIX , он так же тривиален:

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

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

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

npm install stdio
sgmonda
источник
3
В соответствии с TOS SO, стоит упомянуть, что @sgmonda является единственным сопровождающим модуля;) Однако, хороший маленький модуль. Определенно полезно.
Qix - МОНИКА БЫЛА ПОВРЕЖДЕНА
1
Действительно полезно, хотя самое последнее обновление было 30 декабря 2014 года. Может не так хорошо обслуживаться, как некоторые другие пакеты.
fearless_fool
хорошая библиотека! ТКС! Хотя это и без последних обновлений .. У него достаточно хорошая функциональность
Pablo Ezequiel
Это было некоторое время, но я только что выпустил версию 2, с полным обещанием и поддержкой машинописи. :-)
sgmonda
47

Если ваш сценарий называется 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'
Шон Х. Уортингтон
источник
28

Аргументы командной строки стоит посмотреть!

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

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

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

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

Синтаксис на основе команд (стиль git) в форме:

$ executable <command> [options]

Например.

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

Синтаксис команд и подкоманд (стиль Docker) в форме:

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

Например.

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

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

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

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

Применение

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

Применение

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

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

Lloyd
источник
@ Ллойд, это связано с уже возникшей проблемой - здесь . Webstorm передает некоторые дополнительные аргументы.
kboom
@kboom этот вопрос был решен путем partialи stopAtFirstUnknownопций. Смотрите документы .
Ллойд
23

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

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

Вот пример со страницы 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' ]
Златко
источник
21

Вот мое решение 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

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

grebenyuksv
источник
12

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

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

250R
источник
И вот конфигурация , мой собственный, минимальный, только для чтения интерфейс для nconf.
Джоэл Пурра
12

без библиотек: используя 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 & Number

console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' }
Джозеф Мердриньяк
источник
Ваша более длинная версия имеет проблемы со строками, которые содержат точки.
берлинец
Умное решение! Что если я хочу поддерживать оба параметра countи параметры cкомандной строки ( cв качестве псевдонима / сокращения для count)?
Алекс Ванг
Это прекрасно! Но он не использует стандарт «одна черта для одной буквы и две черты для слова». К сожалению, мой вариант слишком длинный и некрасивый, чтобы публиковать здесь, поэтому я добавлю в качестве другого ответа.
isacvale
10

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

Если вы запускаете скрипт с приведенными ниже аргументами

$ node args.js arg1 arg2

Файл: args.js

console.log(process.argv)

Вы получите массив как

 ['node','args.js','arg1','arg2']
Пиюш Сагар
источник
9
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'
Абденнур ТУМИ
источник
1
Это репо больше не доступно на github.
steadweb
8

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 : Каталог node.exe в вашей обработке (C: \ Program Files \ nodejs \ node.exe ')

1: Каталог вашего файла проекта. (proj.js)

2 : Ваш первый аргумент для узла (arg1)

3 : Ваш второй аргумент для узла (arg2)

4 : Ваш третий аргумент для узла (arg3)

ваши фактические аргументы начинают 2ndиндекс формы argvмассива, то есть process.argv[2].

Нуман Дильшад
источник
7

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

Эврен Кутар
источник
Не могу заставить его работать, mapсвойство не определено.
Карам
6

Вы можете проанализировать все аргументы и проверить, существуют ли они.

file: 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']);
Амаду Бах
источник
4

Без библиотек

Если вы хотите сделать это в vanilla 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

Пожалуйста, исправьте код в карте и уменьшите функцию, если вы найдете более элегантное решение, спасибо;)

Кэссиди
источник
1
я согласен, но это может быть короче нет? let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})
Джозеф Мердриньяк
4

Хотя вышеприведенные ответы являются идеальными, и кто-то уже предложил yargs, использовать пакет действительно просто. Это хороший пакет, который делает передачу аргументов в командную строку действительно простой.

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

Пожалуйста, посетите https://yargs.js.org/ для получения дополнительной информации.

Акшай Раджпут
источник
Yargs не влияет на то, как аргументы передаются в командной строке, он только помогает читать их в коде.
user3285954
4

Передавать аргументы легко, а получать их - просто читать массив process.argv, который Node делает доступным везде, в основном. Но вы наверняка захотите прочитать их как пары ключ / значение, поэтому вам потребуется сценарий для его интерпретации.

Джозеф Мердриньяк опубликовал прекрасную статью с использованием 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"
}
isacvale
источник
3

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

Вы также можете использовать библиотеки, такие как yargs, для работы с аргументами commnadline.

Рубин Бхандари
источник
2

Решение 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' }

Роберт Молина
источник
1

process.argvВаш друг, захват аргументов командной строки изначально поддерживается в Node JS. Смотрите пример ниже:

process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
})
bhwp
источник
0

как указано в документе 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
Адехо Эммануэль IMM
источник
0

Большинство людей дали хорошие ответы. Я также хотел бы внести кое-что здесь. Я предоставляю ответ, используя 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
S.Mishra
источник
0

Лучший способ передать аргументы командной строки в программу Node.js - использовать интерфейс командной строки (CLI)

Существует отличный модуль npm, называемый nodejs-cli, который вы можете использовать.

Если вы хотите создать его без зависимостей, у меня есть его на моем Github, если вы хотите проверить его, на самом деле он довольно прост и удобен в использовании, нажмите здесь .

мадхур ачарья
источник
0

Решение 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());
Тибальт
источник