Что такое аргументы командной строки?
Аргументы командной строки - это строки текста, используемые для передачи дополнительной информации программе, когда приложение запускается через интерфейс командной строки (CLI) операционной системы. Аргументы командной строки обычно включают информацию, используемую для установки значений конфигурации или свойств для приложения.
В большинстве случаев аргументы передаются после имени программы в вашем приглашении. Пример синтаксиса аргументов командной строки выглядит так:
$ [runtime] [script_name] [argument-1 argument-2 argument-3 ... argument-n]
Здесь среда выполнения может быть чем угодно, выполняющим программу /
сценарий, например sh , java , node и т. Д. Аргументы обычно
разделяются пробелом, однако есть некоторые среды выполнения, в которых
используются запятые, чтобы различать несколько аргументов командной
строки. Кроме того, в зависимости от программы вы можете передавать
аргументы в виде пар ключ-значение, что мы увидим позже в этой статье.
Зачем использовать аргументы командной строки?
Ниже приведены некоторые из основных преимуществ использования аргументов командной строки:
- Вы можете передать информацию приложению до его запуска. Это особенно полезно, если вы хотите выполнить большое количество настроек конфигурации.
- Аргументы командной строки передаются вашей программе в виде строк. Типы данных String можно легко преобразовать в другие типы данных в приложении, что делает аргументы очень гибкими.
- Вы можете передавать неограниченное количество аргументов через командную строку.
- Аргументы командной строки используются вместе со сценариями и пакетными файлами, что особенно полезно для автоматического тестирования.
И вот некоторые из недостатков их использования:
- Самым большим недостатком передачи информации через командную строку является то, что интерфейс требует сложного обучения, поэтому большинству людей трудно использовать его, если у них нет большого опыта использования инструментов CLI.
- Приложения командной строки могут быть трудными в использовании, если вы не используете настольный или портативный компьютер, поэтому они обычно не используются на небольших устройствах, таких как телефоны или планшеты.
Передача аргументов командной строки в Node.js
Как и многие другие языки, приложения Node.js также принимают аргументы командной строки. По умолчанию Node обрабатывает принятие аргументов за вас, но есть также несколько отличных сторонних пакетов, которые добавляют некоторые очень полезные функции.
В этом разделе мы покажем вам, как использовать аргументы встроенным
способом ( process.argv ), а также с популярными пакетами minimist и
yargs.
Использование process.argv
Самый простой способ получить аргументы в Node.js - через массив
process.argv Это глобальный объект, который можно использовать без
импорта каких-либо дополнительных библиотек для его использования. Вам
просто нужно передать аргументы приложению Node.js, как мы показали
ранее, и к этим аргументам можно получить доступ в приложении через
массив process.argv
Первым элементом process.argv всегда будет путь файловой системы,
указывающий на исполняемый файл node Второй элемент - это имя
исполняемого файла JavaScript. И третий элемент - это первый аргумент,
фактически переданный пользователем.
Чтобы избежать путаницы, я хотел бы напомнить вам, новичкам, что JavaScript использует индексы с нулевым отсчетом для массивов (как и многие другие языки), что означает, что первый элемент будет сохранен в индексе «0», а последний элемент будет сохранен в Индекс «n-1», где «n» - общее количество элементов в массиве.
Теперь давайте напишем простой сценарий Node, который печатает все аргументы командной строки, переданные приложению, вместе с их индексом. Скопируйте и вставьте следующий код в файл с именем processargv.js.
'use strict';
for (let j = 0; j < process.argv.length; j++) {
console.log(j + ' -> ' + (process.argv[j]));
}
Все, что делает этот сценарий, - это перебирает process.argv и
печатает индексы вместе с элементами, хранящимися в этих индексах. Это
очень полезно для отладки, если вы когда-нибудь сомневаетесь, какие
аргументы вы получаете и в каком порядке.
Теперь, чтобы запустить этот тип, введите следующую команду. Просто убедитесь, что вы находитесь в каталоге, в котором сохранен файл "processargv.js".
$ node processargv.js tom jack 43
Здесь мы передаем программе processargv.js три аргумента. Вы увидите, что «tom» будет сохранен во 2-м индексе, а «jack» и «43» будут сохранены в 3-м и 4-м индексах соответственно. Результат должен выглядеть примерно так:
$ node processargv.js tom jack 43
0 -> /Users/scott/.nvm/versions/node/v4.8.0/bin/node
1 -> /Users/scott/javascript/processargv.js
2 -> tom
3 -> jack
4 -> 43
Вы можете видеть, что первый индекс содержит путь к node (который,
вероятно, будет иметь другой путь, чем мой), второй индекс содержит путь
к файлу сценария, а остальные индексы содержат аргументы, которые мы
передали в их соответствующая последовательность.
Использование модуля Minimist
Другой способ получить аргументы командной строки в приложении Node.js -
использовать модуль minimist.
Модуль Minimist проанализирует аргументы из process.argv и преобразует
его в более простой в использовании ассоциативный массив. В
ассоциативном массиве вы можете получить доступ к элементам через имена
индексов в дополнение к номерам индексов. Взгляните на следующий пример.
'use strict';
const args = require('minimist')(process.argv.slice(2));
console.log(args);
console.log(args.i);
Сохраните приведенный выше код в "minimist.js". В приведенном выше
коде мы используем метод slice глобального объекта process.argv В
slice удаляет все предыдущие элементы массива, начиная с индекса,
переданного ему в качестве параметра. Здесь мы знаем, что аргументы,
которые мы передаем вручную, сохраняются, начиная со второго индекса, мы
передали 2 в функцию среза. Затем мы распечатали весь объект args Мы
также напечатали отдельный элемент массива, используя именованный
индекс, то есть «i», а не номер индекса.
Теперь, когда мы передаем аргумент этой программе, мы также можем указать символ, с помощью которого мы хотим получить доступ к элементу. Поскольку в сценарии мы используем индексное имя «i» для доступа к элементу, мы должны указать элемент, хранящийся в этом индексе. Взгляните на сценарий для выполнения указанной выше программы.
$ node minimist.js –i jacob –j 45
Обратите внимание, что здесь мы указали «i» в качестве имени для второго индекса, значение, хранящееся в этом индексе, - «jacob». Точно так же третий индекс называется "j", и значение этого индекса - 45. Результат выполнения вышеуказанной команды будет следующим:
$ node minimist.js -i jacob -j 45
{ _: [], i: 'jacob', j: 45 }
jacob
Несмотря на то, что Minimist не такой многофункциональный, как некоторые
другие модули анализа аргументов (см. yargs ниже), он имеет несколько
полезных функций, на которые вы, возможно, захотите обратить внимание,
например, псевдонимы и значения по умолчанию.
Если вы устанавливаете псевдоним, то вызывающая программа вашей программы может использовать псевдоним в дополнение к обычному имени опции. Это полезно, если вы хотите иметь сокращенное обозначение для ваших вариантов, как показано ниже:
'use strict';
const minimist = require('minimist');
let args = minimist(process.argv.slice(2), {
alias: {
h: 'help',
v: 'version'
}
});
console.log('args:', args);
Вызов этого кода с параметром -h устанавливает как h: true и
help: true в выходные аргументы:
$ node minimist-alias.js -h
args: { _: [], h: true, help: true }
Что касается функции Minimist по умолчанию, если для параметра не передано значение, то значение по умолчанию, которое вы установили в своей программе, будет использоваться автоматически.
'use strict';
const minimist = require('minimist');
let args = minimist(process.argv.slice(2), {
default: {
port: 8080
},
});
console.log('args:', args);
Вызов этого кода без -port прежнему дает вам port в возвращенном
объекте args
$ node minimist-defaults.js
args: { _: [], port: 8080 }
Дополнительные параметры см. В README .
Использование модуля yargs
Еще один модуль, который поможет вам анализировать аргументы командной строки, передаваемые программам Node, - это модуль yargs. Используя этот модуль, вы можете передавать аргументы в виде пар ключ-значение, а затем получать доступ к значениям аргументов в вашей программе, используя соответствующие ключи.
Примечание: вы можете установить yargs с помощью следующей команды:
$ npm install yargs
Теперь взгляните на следующий сценарий:
'use strict';
const args = require('yargs').argv;
console.log('Name: ' + args.name);
console.log('Age: ' + args.age);
В приведенном выше сценарии мы отображаем значения, указанные для аргументов «имя» и «возраст», которые были переданы через командную строку. Теперь сохраните приведенный выше сценарий в файле с именем «yargs.js».
Примечание. Когда вы выполняете указанную выше программу, вам необходимо
передать значения аргументов «имя» и «возраст», в противном случае для
аргументов по умолчанию будет undefined , и вы увидите, что в консоли
записано значение undefined
Чтобы выполнить указанную выше программу, выполните в командной строке следующую команду:
$ node yargs.js --name=jacob --age=45
Здесь мы передаем значения аргументов имени и возраста. Результат вышеупомянутого скрипта будет выглядеть так:
$ node yargs.js --name=jacob --age=45
Name: jacob
Age: 45
Пакет yargs - очень мощный пакет, который не только предоставляет
стандартные функции анализа аргументов, но и множество дополнительных
функций. Хотя мы не будем рассматривать все функции в этой статье, мы,
по крайней мере, коснемся одной из самых популярных функций.
Один из самых эффективных способов использования yargs - это
.command() , которая помогает вам создавать, открывать и вызывать
функции Node через командную строку. Вот простой пример работы этой
функции:
'use strict';
const argv = require('yargs')
.command('upload', 'upload a file', (yargs) => {}, (argv) => {
console.log('Uploading your file now...');
// Do stuff here
}).argv;
Вызов этой программы с помощью команды «upload» вызовет переданную вами
функцию, которая в данном случае просто выводится в командную строку.
Однако я уверен, что вы можете представить себе передачу гораздо более
функциональной функции, которая использует проанализированный argv
чтобы определить, какой файл куда отправить.
Например, эту команду можно вызвать так (при условии, что приведенный выше код хранится в файле с именем "s3-tool.js":
$ node s3-tool.js upload --file=my-file.txt --bucket=my-s3-bucket
Uploading your file now...
И вам не нужно останавливаться на достигнутом, вы даже можете создать команду по умолчанию:
'use strict';
const argv = require('yargs')
.command('*', 'the default command handler', () => {}, (argv) => {
console.log('This function is called by default');
}).argv;
Функция .command() достаточно мощна, чтобы вывести необходимые и
необязательные параметры из строки:
'use strict';
const yargs = require('yargs');
yargs.command('login <username> [password]', 'authenticate with the server').argv
Для получения дополнительной информации о расширенных функциях
ознакомьтесь с yargs расширенным
темам yargs.
Заключение
Это может быть для вас немного удивительно, но, как вы могли заметить,
разбор аргументов на самом деле может быть довольно сложной темой. В
зависимости от ваших потребностей вы можете сделать его настолько
простым или сложным, насколько захотите. yargs , есть подходящее
решение для всех нужд, будь то базовый process.argv или мощный пакет
yargs.
Как вы использовали minimist и yargs для создания программ CLI?
Дайте нам знать об этом в комментариях!