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

$ node server.js folder

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

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

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

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

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

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

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

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

Уточненное право ответ на это его использовать 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' }

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

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

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

Обновить

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

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

Commander.js

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

быстро

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

Co-Prompt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$ node args.js arg1 arg2

Файл: args.js

console.log(process.argv)

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

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

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'

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

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

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

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

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

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

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

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

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

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

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

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

Решение 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' }

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

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

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

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

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

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

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

Решение 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());