У мене на 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 бібліотеку. Раніше ми використовували оптимістичні вузли, але вони з тих пір застаріли.

Ось приклад того, як використовувати його взято прямо з мінімалістичної документації:

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

Ярги : Більш складний розбір аргументів (важкий).

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

Чудово підходить для визначення ваших варіантів, дій та аргументів. Він також генерує довідкові сторінки для вас.

Оперативно

Чудово підходить для отримання інформації від користувача, якщо вам подобається підхід зворотного дзвінка.

Спільний підказ

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

Немає вікон із прапорцями, відформатованими у простий об’єкт

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

Бібліотека Stdio

Найпростіший спосіб розбору аргументів командного рядка в 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
}

Розширене використання

Окрім описаного вище типового використання, ви можете налаштувати командні рядки-args для прийняття більш досконалих форм синтаксису.

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

Типовий приклад посібника із використання.

Посібник із використання полімерних кліпів є хорошим прикладом реального життя.

Подальше читання

Дізнатися є багато іншого, будь ласка, перегляньте вікі для прикладів та документації.

Для цього є додаток. Ну, модуль. Ну, не один, мабуть, сотні.

Ярг - один із найцікавіших, його документи можна класно читати.

Ось приклад зі сторінки 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

Примітка. Звичайно, це не вдасться, коли аргумент містить a =. Це лише для дуже простого використання.

Можливо, це гарна ідея керувати конфігурацією централізовано, використовуючи щось на зразок 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 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.

Пояснення:

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використовувати це рішення.

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

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

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

Якщо ви хочете зробити це у ванілі 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

ps Будь ласка, виправте код на карті та зменшіть функцію, якщо ви знайдете більш елегантне рішення, дякую;)

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

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

Будь ласка, відвідайте https://yargs.js.org/ для отримання додаткової інформації.

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

Джозеф Мердріньяк опублікував прекрасне за допомогою зменшення, але він покладався на 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, для роботи з аргументами comnadline.

Рішення 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}`);
})

як зазначено в документах вузла Властивість 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());