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

$ node server.js folder

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

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

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

2564
milkplus 4 Дек 2010 в 04:56

30 ответов

Лучший ответ

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

Аргументы хранятся в 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
2986
user5532169 3 Мар 2020 в 10:07

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

process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
})
1
Suraj Rao 8 Июн 2018 в 10:35

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

Как указано в документе 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 24 Апр 2018 в 00:14

Решение 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
tibalt 13 Сен 2019 в 13:03

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

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

Обновить

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

122
Sanghyun Lee 13 Сен 2017 в 08:41

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

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

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

0
madhur acharya 25 Янв 2019 в 16:40

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

Если вы хотите сделать это в 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 4 Окт 2017 в 23:07

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

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 11 Дек 2013 в 11:18

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

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

12
250R 26 Май 2012 в 00:10

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

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

usage

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

usage

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

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

27
Lloyd 28 Янв 2018 в 19:37

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

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'
}
56
Léa Gris 4 Сен 2019 в 12:24

Commander.js

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

Оперативно

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

Co - Prompt

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

79
balupton 11 Ноя 2013 в 01:50

Несколько отличных ответов здесь, но все это кажется очень сложным. Это очень похоже на то, как 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"
95
Paul van Jaarsveld 12 Дек 2013 в 05:19

Актуальный правильный ответ для этого - использовать минимистическую библиотеку. Мы привыкли использовать 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' }
351
real_ate 8 Июл 2014 в 17:26

Если ваш сценарий называется 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'
47
riper 18 Янв 2017 в 18:24

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

304
dthree 20 Июн 2018 в 16:57
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
Abdennour TOUMI 23 Июл 2016 в 20:37

Вы можете получить аргументы командной строки, используя 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
Evren Kutar 10 Авг 2016 в 13:38

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

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

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

3
Akshay Rajput 12 Дек 2018 в 08:25

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

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' ]
23
Kevin Burke 20 Мар 2017 в 19:44

< Сильный > 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].

8
Jithin Scaria 2 Июл 2018 в 14:19

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

Джозеф Мердриньяк опубликовал прекрасную статью с использованием Reduce, но вместо -k value и --key 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"
}
4
isacvale 25 Фев 2019 в 16:34

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

Без библиотек: использование 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' }
12
Joseph Merdrignac 19 Окт 2017 в 18:41

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

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

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

658
bjb568 4 Окт 2015 в 00:44

Решение TypeScript без библиотек:

interface IParams {
  [key: string]: string
}

function parseCliParams(): IParams {
  const args: IParams = {};
  const rawArgs = process.argv.slice(2, process.argv.length);
  rawArgs.forEach((arg: string, index) => {
    // Long arguments with '--' flags:
    if (arg.slice(0, 2).includes('--')) {
      const longArgKey = arg.slice(2, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: --connection connection_name
      args[longArgKey] = longArgValue;
    }
    // Shot arguments with '-' flags:
    else if (arg.slice(0, 1).includes('-')) {
      const longArgKey = arg.slice(1, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: -c connection_name
      args[longArgKey] = longArgValue;
    }
  });
  return args;
}

const params = parseCliParams();
console.log('params: ', params);

Вход: ts-node index.js -p param --parameter parameter

Выход: { p: 'param ', parameter: 'parameter' }

0
Robert Molina 3 Мар 2020 в 18:52

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

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

$ node args.js arg1 arg2

Файл: args.js

console.log(process.argv)

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

 ['node','args.js','arg1','arg2']
10
Piyush Sagar 11 Янв 2016 в 14:54

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

Самым простым способом анализа аргументов командной строки в 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, required: 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
50
sgmonda 19 Дек 2019 в 12:21

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

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

21
Stan James 9 Авг 2018 в 15:21