Aby znormalizować argumenty, takie jak zwykła funkcja javascript, robię to w moim węźle.skrypty powłoki js:

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

Zauważ, że pierwszy arg jest zwykle ścieżką do nodejs, a drugi arg jest lokalizacją skryptu, który wykonujesz.

Up-to-date rightanswer to this it to use the minimist library. Kiedyś używaliśmy node-optimist , ale od tego czasu zostało to przestarzałe.

Oto przykład jak z niego korzystać zaczerpnięty prosto z dokumentacji minimista:

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 odpowiedź na podstawie aktualnych trendów w dziczy:

Parsowanie argumentów javascript:

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

To zwraca:

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

Oficjalne dokumenty

Najczęściej używane Pakiety NPM do parsowania argumentów:

Minimist: dla minimalnego parsowania argumentów.

Komandorze.js: najbardziej przyjęty moduł do parsowania argumentów.

Miau: lżejsza alternatywa dla Komandorze.js

Yargs: bardziej wyrafinowane parsowanie argumentów (ciężkie).

Vorpal.js: Dojrzałe / interaktywne aplikacje wiersza poleceń z parsowaniem argumentów.

Optimist (node-optimist)

Sprawdź optimist library , jest to znacznie lepsze niż ręczne parsowanie opcji wiersza poleceń.

Update

Kilka świetnych odpowiedzi tutaj, ale to wszystko wydaje się bardzo skomplikowane. Jest to bardzo podobne do tego, jak skrypty bash uzyskują dostęp do wartości argumentów i jest już standardowo dostarczane z węzłem.js jak zauważył MooGoo. (Żeby było zrozumiałe dla kogoś, kto jest nowy w node.js)

Przykład:

$ 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"

Komandorze.js

Świetnie nadaje się do definiowania opcji, akcji i argumentów. Generuje również strony pomocy dla Ciebie.

Działa świetnie do uzyskiwania danych wejściowych od użytkownika, jeśli podoba Ci się podejście callback.

Co-Prompt

Działa świetnie do pobierania danych od użytkownika, jeśli podoba Ci się podejście generatora.

Biblioteka Stdio

Najprostszym sposobem analizy argumentów wiersza poleceń w NodeJS jest użycie modułu stdio . Zainspirowany UNIXEM getopt utility, jest tak trywialny jak:

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

Jeśli uruchomisz poprzedni kod z tą komendą:

node <your_script.js> -c 23 45 --map -k 23 file1 file2

Wtedy ops obiekt będzie wyglądał następująco:

{ check: [ '23', '45' ],
  args: [ 'file1', 'file2' ],
  map: true,
  kaka: '23' }

Więc możesz go używać, jak chcesz. Na przykład:

if (ops.kaka && ops.check) {
    console.log(ops.kaka + ops.check[0]);
}

Obsługiwane są również opcje Grupowe, więc można pisać -om zamiast -o -m.

Ponadto, {[10] } może automatycznie wygenerować wynik pomocy/użycia. Jeśli zadzwonisz ops.printHelp() otrzymasz:

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

Poprzednia wiadomość jest wyświetlana również wtedy, gdy opcja obowiązkowa nie jest podana (poprzedzona Komunikatem o błędzie) lub gdy jest błędnie zdefiniowana (na przykład, jeśli podano pojedynczy arg dla opcji i wymaga ona 2).

Możesz zainstalować stdio Moduł używając NPM:

npm install stdio

Jeśli twój skrypt nazywa się myScript.js i chcesz podać imię i nazwisko, 'Sean Worthington' , jako argumenty jak poniżej:

node myScript.js Sean Worthington

Następnie w skrypcie piszesz:

var firstName = process.argv[2]; // Will be set to 'Sean'
var lastName = process.argv[3]; // Will be set to 'Worthington'

Command-line-args jest wart obejrzenia!

Możesz ustawić opcje używając głównych standardów notacji (dowiedz się więcej ). Wszystkie te polecenia są równoważne, ustawiając te same wartości:

$ 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

Aby uzyskać dostęp do wartości, najpierw Utwórz listę definicji opcji opisujących opcje, które aplikacja akceptuje. Na type właściwość jest funkcją ustawiającą (przekazywana przez nią wartość), dającą pełną kontrolę nad wartością przyjąłem.

const optionDefinitions = [
  { name: 'verbose', alias: 'v', type: Boolean },
  { name: 'src', type: String, multiple: true, defaultOption: true },
  { name: 'timeout', alias: 't', type: Number }
]

Następnie przeanalizuj opcje używając commandLineArgs():

const commandLineArgs = require('command-line-args')
const options = commandLineArgs(optionDefinitions)

options teraz wygląda tak:

{
  src: [
    'one.js',
    'two.js'
  ],
  verbose: true,
  timeout: 1000
}

Zaawansowane użycie

Oprócz powyższego typowego użycia, możesz skonfigurować args linii poleceń tak, aby akceptowały bardziej zaawansowane formularze składni.

Składnia oparta o polecenia (styl git) w postaci:

$ executable <command> [options]

Na przykład.

$ git commit --squash -m "This is my commit message"

Składnia polecenia i polecenia (styl docker) w forma:

$ executable <command> [options] <sub-command> [options]

Na przykład.

$ docker run --detached --image centos bash -c yum install -y httpd

Generowanie instrukcji użytkowania

Instrukcja użycia (Zwykle drukowana, gdy ustawiono --help) może być wygenerowana za pomocą command-line-usage. Zobacz poniższe przykłady i przeczytaj dokumentację , aby dowiedzieć się, jak je utworzyć.

Typowy przykład użycia.

Przewodnik użycia polimeru-CLI jest dobrym przykładem prawdziwego życia.

Dalej Czytanie

Jest wiele więcej do nauczenia się, zobaczwiki dla przykładów i dokumentacji.

Jest do tego aplikacja. Moduł. Cóż, więcej niż jeden, prawdopodobnie setki.

Yargs {[6] } jest jednym z tych zabawnych, jego dokumenty są fajne do czytania.

Oto przykład ze strony github/npm:

#!/usr/bin/env node
var argv = require('yargs').argv;
console.log('(%d,%d)', argv.x, argv.y);
console.log(argv._);

Wyjście jest tutaj (czyta opcje z myślnikami itp., krótkie i długie, numeryczne itp.).

$ ./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' ]

Prawdopodobnie dobrym pomysłem jest scentralizowane zarządzanie konfiguracją przy użyciu czegoś takiego jak nconf https://github.com/flatiron/nconf

Pomaga pracować z plikami konfiguracyjnymi, zmiennymi środowiskowymi, argumentami wiersza poleceń.

Przekazywanie, parsowanie argumentów jest łatwym procesem. Node zapewnia Ci proces.właściwość argv, która jest tablicą łańcuchów, które są argumentami, które były używane podczas wywoływania węzła. Pierwszym wpisem tablicy jest plik wykonywalny węzła, a drugim wpisem jest nazwa skryptu.

Jeśli uruchomisz skrypt z poniższymi dokumentami ATG

$ node args.js arg1 arg2

Plik: args.js

console.log(process.argv)

Otrzymasz tablicę jak

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

Whithout librairies: using Array.prototyp.reduce ()

const args = process.argv.slice(2).reduce((acc, arg) => {

    let [k, v = true] = arg.split('=')
    acc[k] = v
    return acc

}, {})

Dla tej komendy node index.js count=2 print debug=false msg=hi

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

Również,

Możemy zmienić

    let [k, v = true] = arg.split('=')
    acc[k] = v

By (znacznie dłużej)

    let [k, v] = arg.split('=')
    acc[k] = v === undefined ? true : /true|false/.test(v) ? v === 'true' : /[\d|\.]+/.test(v) ? Number(v) : v

To auto parse Boolean & Number

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

Możesz przeanalizować wszystkie argumenty i sprawdzić, czy istnieją.

Plik: 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;
}

Niż po prostu zrobić:

var arguments = require('./parse-cli-arguments')(['foo', 'bar', 'xpto']);

npm install ps-grab

Jeśli chcesz uruchomić coś takiego:

node greeting.js --user Abdennour --website http://abdennoor.com 

--

var grab=require('ps-grab');
grab('--username') // return 'Abdennour'
grab('--action') // return 'http://abdennoor.com'

Lub coś w stylu:

node vbox.js -OS redhat -VM template-12332 ;

--

var grab=require('ps-grab');
grab('-OS') // return 'redhat'
grab('-VM') // return 'template-12332'

Możesz dotrzeć do argumentów linii poleceń używając system.args. I używam poniższego rozwiązania, aby przetworzyć argumenty do obiektu, więc mogę uzyskać, który z nich chcę po nazwie.

var system = require('system');

var args = {};
system.args.map(function(x){return x.split("=")})
    .map(function(y){args[y[0]]=y[1]});

Teraz nie musisz znać indeksu argumentu. użyj go jak args.whatever

Uwaga: Należy używać nazwanych argumentów, takich jak file.js x=1 y=2, aby używać To rozwiązanie.

Proj.js

for(var i=0;i<process.argv.length;i++){
  console.log(process.argv[i]);
}

Terminal:

nodemon app.js "arg1" "arg2" "arg3"

Wynik:

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 : Katalog węzła.exe w Twojej machinacji (C:\Program Files\nodejs\node.exe")

1 : katalog Twojego pliku projektu. (proj.js)

2 : Twój pierwszy argument do node (arg1)

3 : twój drugi argument do node (arg2)

4 : twój trzeci argument do węzła (arg3)

Twoje rzeczywiste argumenty zaczynają się od 2nd indeksu argv tablicy, czyli process.argv[2].

Oto moje rozwiązanie 0-dep dla nazwanych argumentów:

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)

Przykład:

$ node test.js foo=bar fizz=buzz
bar
buzz

Uwaga: oczywiście nie powiedzie się, gdy argument zawiera =. Jest to tylko do bardzo prostego użycia.

Bez bibliotek

Jeśli chcesz to zrobić w vanilla JS / ES6 możesz użyć następującego rozwiązania

Pracował tylko w 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;
  }, {});

I to polecenie

node index.js host=http://google.com port=8080 production

Da następujący wynik

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. proszę poprawić kod na mapie i zmniejszyć funkcję jeśli znajdziesz bardziej eleganckie rozwiązanie, dzięki;)

Najprostszy sposób pobierania argumentów w Node.js jest przez proces.array argv. Jest to obiekt globalny, którego można używać bez importowania żadnych dodatkowych bibliotek. Po prostu musisz przekazać argumenty do węzła.aplikacja js, tak jak pokazaliśmy wcześniej, i te argumenty mogą być dostępne w aplikacji za pośrednictwem procesu.array argv.

Pierwszy element procesu.tablica argv zawsze będzie ścieżką systemu plików wskazującą na plik wykonywalny węzła. Drugi element jest nazwą wykonywanego pliku JavaScript. A trzeci element jest pierwszym argumentem, który został faktycznie przekazany przez użytkownika.

'use strict';

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

Ten skrypt robi tylko pętlę przez proces.tablica argv i wypisuje indeksy wraz z elementami przechowywanymi w tych indeksach. Jest to bardzo przydatne do debugowania, jeśli kiedykolwiek kwestionujesz, jakie argumenty otrzymujesz i w jakiej kolejności.

Możesz również używać bibliotek takich jak yargs do pracy z argumentami commnadline.

Jak podano w node docs Proces.właściwość argv zwraca tablicę zawierającą argumenty linii poleceń przekazane przez węzeł.rozpoczęto proces js.

Na przykład, zakładając następujący skrypt dla process-args.js:

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

Uruchamianie węzła.proces js jako:

 $ node process-args.js one two=three four

Wygeneruje wyjście:

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four

Większość ludzi udzieliła dobrych odpowiedzi. Chciałbym również wnieść w tym miejscu swój wkład. Odpowiadam przy użyciu biblioteki lodash do iteracji wszystkich argumentów linii poleceń, które przekazujemy podczas uruchamiania aplikacji:

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

Aby uruchomić powyższy kod wystarczy uruchomić następujące polecenia:

npm install
node index.js xyz abc 123 456

Wynik będzie:

xyz 
abc 
123
456

process.argv jest twoim przyjacielem, przechwytywanie args linii poleceń jest natywnie obsługiwane w Node JS. Zobacz przykład poniżej::

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

Możesz również użyć pakietu yargs to znacznie ułatwi sprawę! proszę bardzo:)

Prosty fragment jeśli jest potrzebny:

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