it-swarm.com.ru

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

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

$ node server.js folder

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

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

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

2016
milkplus

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

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

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

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

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

549
Mauvis Ledford

В последнем right ответе на это используется библиотека 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' }
289
real_ate

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

253
dthree

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

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

Обновление

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

114
gor

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

Commander.js

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

Оперативно

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

Совместный запрос

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

70
balupton

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

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

npm install stdio
41
sgmonda

Если ваш сценарий называется 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'
36
Sean H. Worthington

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

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

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

usage

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

usage

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

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

23
Lloyd

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

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

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

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

function getArgs () {
  const args = {}
  process.argv
    .slice(2, process.argv.length)
    .forEach( arg => {
      // long arg
      if (arg.slice(0,2) === '--') {
        const longArg = arg.split('=')
        args[longArg[0].slice(2,longArg[0].length)] = longArg[1]
      }
     // 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' }
13
Michael Warner

без библиотек: используя 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' }
10
Joseph Merdrignac

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

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

10
250R

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

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

$ node args.js arg1 arg2

Файл: args.js

console.log(process.argv)

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

 ['node','args.js','arg1','arg2']
9
Piyush Sagar

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

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

9
grebenyuksv
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'
7
Abdennour TOUMI

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

6
Evren Kutar

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

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']);
6
Amadu Bah

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.

Объяснение:

0: каталог node.exe в вашей обработке (C:\Program Files\nodejs\node.exe ')

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

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

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

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

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

5
Nouman Dilshad

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

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

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

4
Cassidy

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

3
Rubin bhandari

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

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

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

1
Akshay Rajput

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

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

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

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

0
madhur acharya

как указано в документе 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
0
Adeojo Emmanuel IMM

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

process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
})
0
bhwp

Передавать аргументы легко, а получать их - просто читать массив 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"
}
0
isacvale