У меня есть веб-сервер, написанный в Node.js, и я хотел бы запустить его с определенной папкой. Я не уверен, как обращаться к аргументам в JavaScript. Я запускаю node следующим образом:
$ node server.js folder
здесь server.js - мой код сервера. Node.js help говорит, что это возможно:
$ node -h
Usage: node [options] script.js [arguments]
Как мне получить доступ к этим аргументам в JavaScript? Как-то я не смог найти эту информацию в Интернете.
Аргументы хранятся в 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
Чтобы нормализовать аргументы, подобные обычной функции javascript, я получаю это в своих сценариях оболочки node.js:
var args = process.argv.slice(2);
Обратите внимание, что первым аргументом обычно является путь к nodejs, а второй arg - это местоположение выполняемого script.
Последний правильный ответ для этого, чтобы использовать библиотеку 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' }
const args = process.argv;
console.log(args);
Это возвращает:
$ node server.js one two=three four
['node', '/home/server.js', 'one', 'two=three', 'four']
Минимист: для минимального разбора аргумента.
Commander.js: Самый популярный модуль для разбора аргументов.
Мяу: более легкая альтернатива Commander.js
Яргс: более сложный анализ аргументов (тяжелый).
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"
Отлично подходит для определения ваших опций, действий и аргументов. Он также создает страницы справки для вас.
Работает отлично для получения ввода от пользователя, если вам нравится подход обратного вызова.
Хорошо работает для получения ввода от пользователя, если вам нравится подход к генератору.
Если ваш 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'
Самый простой способ проанализировать аргументы командной строки в 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
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'
}
Аргументы командной строки стоит посмотреть!
Вы можете установить параметры, используя основные стандарты обозначений (узнать больше). Все эти команды эквивалентны, устанавливая одинаковые значения:
$ 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
Он помогает вам работать с файлами конфигурации, переменными среды, аргументами командной строки.
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, а вторая запись - имя вашего script.
Если вы запустите script с помощью нижеуказанных
$ 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
p.s. Исправьте код на карте и уменьшите функцию если вы найдете более элегантное решение, спасибо;)
Самый простой способ получения аргументов в 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.
Передать аргументы легко, а получить их - просто прочитать массив 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"
}
Хотя вышеприведенные ответы идеальны, и кто-то уже предложил yargs, использовать пакет действительно просто. Это хороший пакет, который делает передачу аргументов в командную строку действительно простой.
npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);
Пожалуйста, посетите https://yargs.js.org/ для получения дополнительной информации.
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 все аргументы командной строки, которые мы передаем при запуске приложения:
// 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());
Аргумент разбора на основе стандартного ввода (--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"
}