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

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

$ node server.js folder

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

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

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

+2237
источник поделиться
32 ответа
  • 1
  • 2

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

Аргументы хранятся в process.argv

Ниже приведены документы node при обработке команд командной строки:

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
+2875
источник

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

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

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

+619
источник
другие ответы

Связанные вопросы


Похожие вопросы

Последний правильный ответ для этого, чтобы использовать библиотеку minimist. Раньше мы использовали node-optimist, но с тех пор он устарел.

Вот пример того, как использовать его непосредственно из документации 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' }
+323
источник

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

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

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

+290
источник

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

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

Обновить

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

+121
источник

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

Commander.js

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

Promptly

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

Co-Prompt

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

+77
источник

Если ваш script называется myScript.js, и вы хотите передать имя и фамилию, "Sean Worthington", в качестве аргументов, как показано ниже:

node myScript.js Sean Worthington

Затем в вашем script вы пишете:

var firstName = process.argv[2]; // Will be set to 'Sean'
var lastName = process.argv[3]; // Will be set to 'Worthington'
+44
источник

Библиотека Stdio

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

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 модуль NPM:

npm install stdio
+44
источник

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

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'
}
+38
источник

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

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

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

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

usage

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

usage

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

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

+27
источник

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

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

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

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

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

+17
источник

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

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

+11
источник

без librairies: использование 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' }
+11
источник

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

Если вы запустите script с помощью нижеуказанных

$ node args.js arg1 arg2

Файл: args.js

console.log(process.argv)

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

 ['node','args.js','arg1','arg2']
+10
источник
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'
+9
источник

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

+8
источник

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

+7
источник

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

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
источник

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

Если вы хотите сделать это в 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. Исправьте код на карте и уменьшите функцию если вы найдете более элегантное решение, спасибо;)

+4
источник

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

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

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

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

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

+2
источник

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

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

как указано в документе 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
источник

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

Лучший способ передать аргументы командной строки в программу 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());
0
источник

Аргумент разбора на основе стандартного ввода (--key=value)

const argv = (() => {
    const arguments = {};
    process.argv.slice(2).map( (element) => {
        const matches = element.match( '--([a-zA-Z0-9]+)=(.*)');
        if ( matches ){
            arguments[matches[1]] = matches[2]
                .replace(/^['"]/, '').replace(/['"]$/, '');
        }
    });
    return arguments;
})();

Пример команды

node app.js --name=stackoverflow --id=10 some-another-argument --text="Hello World"

Результат argv: console.log(argv)

{
    name: "stackoverflow",
    id: "10",
    text: "Hello World"
}
0
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос