javascript - parser - npm parse args




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

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

Meow : более легкая альтернатива Commander.js

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

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

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

$ node server.js folder

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

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

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


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

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

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


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

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

Обновить

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


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

Аргументы хранятся в 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

Commander.js

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

Promptly

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

Co-Prompt

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


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

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

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


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


Вы также можете использовать пакет yargs, это сделает многое намного проще! здесь вы идете :) Yargs


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

Yargs является одним из самых интересных, его документы 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' ]

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

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

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

$ node args.js arg1 arg2

Файл: args.js

console.log(process.argv)

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

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

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

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


как указано в документе узла. Свойство 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

command-line-args стоит посмотреть!

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

$ 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 ) может быть сгенерировано с использованием command-line-usage . См. Приведенные ниже примеры и command-line-usage о том, как их создавать.

Типичный пример использования.

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

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

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


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 : Ваш первый аргумент node (arg1)

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

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

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


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'




command-line-arguments