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

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

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

вверх-к-дата право ответ для этого он должен использовать minimist библиотека. Мы использовали узел-оптимистка но с тех пор он был устаревшим.

вот пример того, как использовать его, взятый прямо из документации minimist:

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 Vanilla:

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

возвращает:

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

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

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

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

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

Мяу: более светлая альтернатива к командиру.js

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

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

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

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

обновление

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

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

командир.js

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

быстро

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

Со Строки

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

Библиотека Stdio

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

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

предыдущее сообщение отображается также, если обязательный параметр не задан (предшествует сообщению об ошибке) или если он неверно определен (например, если вы указали один arg для параметра и ему нужно 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'

командная строка-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

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

дополнительные функции

помимо приведенного выше типичного использования, вы можете настроить command-line-args для приема более сложных синтаксических форм.

(git style) в виде:

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

типичное руководство по использованию образец.

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

Более Дальнеишее Чтение

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

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

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' ]

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

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

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

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

$ node args.js arg1 arg2

File: args.js

console.log(process.argv)

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

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

whithout librairies: использование массива.прототип.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

by (намного дольше)

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

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

file:parse-cli-аргументы.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']);

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'

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

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 - каталог узла.exe в вашем maching (C:\Program файлы\nodejs\узел.exe')

1 - каталог, в файл проекта. (proj.в JS)

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

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

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

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

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

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

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

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

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

самый простой способ получения аргументов в Node.js через процесс.агду массива. Это глобальный объект, который можно использовать без импорта дополнительных библиотек. Вам просто нужно передать аргументы узлу.приложения на JS, как мы показали ранее, и эти аргументы могут быть доступны в приложении через процесс.агду массива.

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

'use strict';

for (let j = 0; j < process.argv.length; j++) {  
    console.log(j + ' -> ' + (process.argv[j]));
}

все, что делает этот скрипт, это цикл через процесс.argv массив и печатает индексы вместе с элементами, хранящимися в этих индексах. Это очень полезно для отладки, если вы когда-либо задавались вопросом, какие аргументы вы получаете и в каком порядке.

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

как говорится в узел "документы" Процесс.свойство argv возвращает массив, содержащий аргументы командной строки, переданные узлом.был запущен процесс js.

например, предполагая следующий сценарий для process-args.js:

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

запуск узла.Яш процесс как:

 $ 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

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

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

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

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

простой фрагмент, если он нужен:

var fs = require('fs'), objMod = {};

process.argv.slice(2).map(function(y, i) {
  y = y.split('=');
  if (y[0] && y[1]) objMod[y[0]] = y[1];
  else console.log('Error in argument number ' + (i+1));
});