— это код моего сервера. Справка Node.js говорит, что это возможно: для JavaScript на стороне сервера) или использует «Polyfill». Polyfill для этой функциональности, однако, тривиален, и, поскольку он делает код более легким для чтения, его стоит включить в Polyfill. и я хотел бы запустить с определенной папкой. Я не уверен, как получить доступ к аргументам в JavaScript. Я запускаю узел следующим образом:

$ node server.js folder

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

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

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

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

. Здесь находятся process.argv

документы узлов по обработке аргументов командной строки: — это массив, содержащий аргументы командной строки. Первым элементом будет «узел», вторым элементом будет имя файла JavaScript. Следующими элементами будут любые дополнительные аргументы командной строки.

process.argv Это сгенерирует:

// print process.argv
process.argv.forEach(function (val, index, array) {
  console.log(index   ': '   val);
});

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

$ 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

было бы неплохо использовать JSONP в качестве типа данных, но в моем случае я не знаю, нужен ли домен, к которому мне нужен доступ поддерживает данные в этом формате.

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

Актуальный

правильный ответ, чтобы использовать библиотеку . Мы привыкли использовать JSXGraph node-optimist , но с тех пор он устарел. Вот пример того, как его использовать, взятый прямо из минимистической документации:

ответ 2018 года, основанный на текущих тенденциях в дикой природе:

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

Разбор аргументов ванильного сценария JavaScript:


Возвращает:

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

Официальный docs

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

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


Minimist

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

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

Яргс : более легкая альтернатива Commander.js

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

: зрелые / интерактивные приложения командной строки с разбором аргументов. Оптимист (node-optimist)

библиотека оптимистов

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

ОБНОВЛЕНИЕ

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

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

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

Библиотека Stdio

Самый простой способ анализа аргументов командной строки в NodeJS — это использование модуля

stdio . Вдохновлен UNIX Если вы запустите предыдущий код с помощью этой команды: getopt, Это так же тривиально, как указано ниже: В более ранних версиях jQuery это возвращает пустую строку. В 1.6 он возвращает правильное значение,

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

method: 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 ).

Вы можете установить . Вдохновлен UNIX модуль с помощью NPM :

npm install stdio

совпадает с объектом экспорта. Смотрите

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'

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

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

usage

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

usage

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

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

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

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

Примеры

Он предотвращает или выдает ошибки, когда предпринимаются относительно «небезопасные» действия (например, получение доступа к глобальному объекту).

Input {*) } th

node test.js -D --name=Hello

Вывод

{ D: true, name: 'Hello' }

Реальный мир

Input {*) } th

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

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

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

. Вот пример из 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

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

без библиотек: используя 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 & amp ; Number

console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' }

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

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

Передача, анализ аргументов — это простой процесс. 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'

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

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

файл: 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']);

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 на вашем компьютере (C: Program Files nodejs node.exe ‘)

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

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

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

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

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

работал только в

. Это правильно и должно дать вам значение. Это текст, который вы ‘ re after?

NodeJS & gt ; 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

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

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

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

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

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

'use strict';

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

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

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

Джозеф Мердриньяк опубликовал прекрасную статью, в которой использовался 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, как указано в документе узла. Свойство process.argv возвращает массив, содержащий аргументы командной строки, переданные при запуске процесса Node.js.


args = {
 "alpha":true,
 "beta":true,
 "c":true,
 "h":true,
 "a":true,
 "r":true
 "l":true,
 "i":true,
 "e":"delta",
 "echo":"foxtrot"
}

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

Запуск процесса Node.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();

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

npm install
node index.js xyz abc 123 456

Результатом будет:

xyz 
abc 
123
456

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

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

Существует отличный модуль npm, называемый

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

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

Простой фрагмент, если он понадобится: Перегрузка функций в Javascript — Лучшие практики — Переполнение стека

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));
});