Metoda Standard (de biblioteca)

Argumentele sunt stocate în proces.argv`

Aici sunt nodul documente privind manipularea linie de comandă argumente:

`proces.argv este un tablou care conține argumente în linia de comandă. Primul element va fi 'nod', cel de-al doilea element va fi numele de fișier JavaScript. Următoarele elemente vor fi de nici o suplimentare de argumente în linia de comandă.

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

Acest lucru va genera:

$ 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

Pentru a normaliza argumente ca o funcție javascript-ar primi, am face acest lucru în mea node.js scripturi shell:

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

Rețineți că primul argument este, de obicei, calea de a nodejs, și cel de-al doilea argument este locația de script're de executare.

Up-to-data de dreapta răspunde pentru acest lucru este de a utiliza minimist biblioteca. Am folosit pentru a folosi nod-optimist dar de atunci a fost depreciat.

Aici este un exemplu de cum să-l folosească luate direct din minimist documentație:

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 răspuns bazat pe tendințele actuale în sălbăticie:

Vanilie javascript argument de parsare:

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

Acest lucru se întoarce:

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

Documente oficiale

Cele mai utilizate NPM pachete pentru argumentul de parsare:

Minimist: Pentru minim argument parsarea.

Commander.js: a adoptat cele Mai multe module pentru argumentul de parsare.

Miau: Bricheta alternativă la Commander.js

Yargs: Mai sofisticate argument de parsare (grele).

Vorpal.js: / Mature interactive aplicații în linia de comandă cu argument de parsare.

Optimist (nod-optimist)

Check out optimist biblioteca, este mult mai bine decât parsarea opțiuni de linie de comandă de mână.

Update

Optimist este învechită. Încerca yargs, care este un activ furculiță de optimist.

Mai multe răspunsuri aici, dar totul pare foarte complex. Acest lucru este foarte similar cu modul în bash script-uri de acces argument valori și it's deja furnizate standard cu node.js ca MooGoo subliniat. (Doar pentru a face mai ușor de înțeles pentru cineva care's nou la node.js)

Exemplu:

$ 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

Lucrari de mare pentru a defini opțiunile, acțiunile și argumentele. Acesta generează, de asemenea, paginile de ajutor pentru tine.

Prompt

Lucrari de mare pentru a obține de intrare de la utilizator, dacă vă place callback abordare.

Co-Prompt

Lucrari de mare pentru a obține de intrare de la utilizator, dacă vă place generator de abordare.

Biblioteca Stdio

Cel mai simplu mod de a analiza argumente în linia de comandă în NodeJS este folosind stdio modulul. Inspirat de UNIX getopt de utilitate, este la fel de banal, după cum urmează:

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

Dacă tu a alerga codul anterior cu această comandă:

node  -c 23 45 --map -k 23 file1 file2

Apoi " ops " obiect va fi după cum urmează:

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

Astfel încât să puteți folosi după cum doriți. De exemplu:

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

Grupate opțiuni sunt, de asemenea, sprijinite, astfel încât să puteți scrie -om în loc de -o-m.

În plus, stdio poate genera un ajutor/utilizare de ieșire în mod automat. Daca ai ops.printHelp()` te'll a obține următoarele:

USAGE: node something.js [--check  ] [--kaka] [--ooo] [--map]
  -c, --check     What this option means (mandatory)
  -k, --kaka                  (mandatory)
  --map                       Another description
  -o, --ooo

Mesajul anterior este prezentat, de asemenea, dacă obligatorie opțiune nu este dat (precedate de un mesaj de eroare) sau dacă este mispecified (de exemplu, dacă specificați un singur argument pentru o opțiune și este nevoie de 2).

Puteți instala stdio modulul folosind MNP:

npm install stdio

Dacă scriptul este numit myScript.js și vrei să treci primul și ultimul nume, 'Sean Worthington', ca argumente de genul de mai jos:

node myScript.js Sean Worthington

Apoi în script scrie:

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

Nu Libs cu Steaguri Formatat într-un Simplu Obiect

js funcția getArgs () { const args = {}; proces.argv .felie(2, proces.argv.lungime) .forEach( arg => { // timp arg dacă (arg.felie(0,2) === '--') { const longArg = arg.split('='); const longArgFlag = longArg[0].felie(2,longArg[0].lungimea); const longArgValue = longArg.lungime > 1 ? longArg[1] : true; args[longArgFlag] = longArgValue; } // steaguri altceva dacă (arg[0] === '-') { const steaguri = arg.felie(1,arg.lungime).split(''); steaguri.forEach(flag => { args[flag] = true; }); } }); reveni args; } const args = getArgs(); console.log(args);

Exemple

Simplu

intrare

sh nod test.js -D --name=Salut

ieșire

js { D: adevărat, nume: 'Salut' }

Lumea Reală

intrare

sh nod config/build.js -lHRs --ip=$HOST --port=$PORT ... env=dev

ieșire js { l: adevărat, H: adevărat, R: adevărat, s: adevărat, ip: '127.0.0.1', port: '8080', env: 'dev' }

comanda online-args este în valoare de o privire!

Puteți seta opțiuni folosind principalele notații standarde (afla mai multe). Aceste comenzi sunt echivalente, stabilind aceleași valori:

$ 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

Pentru a accesa valorile, în primul rând a crea o listă de opțiunea definiții descrie opțiunile aplicația dvs. acceptă. La type proprietatea este un setter funcția (valoarea furnizată este trecut prin asta), oferindu-vă control complet asupra valorii primite.

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

Apoi, analiza de opțiuni folosind commandLineArgs():

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

"opțiuni" acum arata ca acest lucru:

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

Utilizare avansată

Pe lângă cele de mai sus tipice de utilizare, aveți posibilitatea să configurați linia de comandă-args să accepte mai avansate sintaxa forme.

Pe bază de comandă sintaxă (git stil) în forma:

$ executable  [options]

De exemplu.

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

Comanda și sub-comandă syntax (docher stil) în forma:

$ executable  [options]  [options]

De exemplu.

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

Ghid de utilizare generație

Un ghid de utilizare (de obicei imprimate atunci când --help este setat) pot fi generate folosind comanda online-utilizare. A se vedea exemplele de mai jos și citește documentația pentru instrucțiuni despre cum să le creați.

Un exemplu tipic de utilizare ghid de exemplu.

De polimer-cli ghidul de utilizare este un bun exemplu din viața reală.

Lecturi Suplimentare

Există o mulțime mai mult pentru a afla, vă rugăm să consultați wiki pentru exemple și documentație.

Nu's o aplicație pentru asta. Ei bine, module. Ei bine, mai mult de unul, probabil, sute.

Yargs este unul dintre cele amuzante, sa docs sunt interesante de citit.

Aici's un exemplu de la github/npm pagina:

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

De ieșire este aici (se citește opțiuni cu liniuțe etc, pe termen scurt și lung, numeric etc.).

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

Aici's 0-dep soluție pentru nume argumente:

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)

Exemplu:

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

Notă: în mod Natural acest lucru va eșua în cazul în care argumentul conține o =. Acest lucru este doar pentru foarte simplu de utilizare.

fără biblioteci: folosind Matrice.prototip.reduce()

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

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

}, {})

pentru această comandă nod index.js count=2 print debug=false msg=hi

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

de asemenea,

putem schimba

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

de (mult mai)

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

la auto-analiza Boolean & Numărul

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

L's, probabil, o idee bună de a gestiona dvs. de configurare în mod centralizat, folosind ceva de genul nconf https://github.com/flatiron/nconf

Aceasta vă ajută să lucrați cu fișiere de configurare, variabilele de mediu, argumente în linia de comandă.

In trecere,parsarea argumente este un proces ușor. Nod oferă cu procesul.argv de proprietate, care este o matrice de siruri de caractere, care sunt argumentele care au fost utilizate atunci când Nodul a fost invocat. Prima intrare din matrice este Nodul executabil, și cea de-a doua intrare este numele de script-ul.

Dacă tu a alerga script-ul de mai jos, cu atguments

$ node args.js arg1 arg2

Fișier : args.js

console.log(process.argv)

Veți obține matrice de genul

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

npm install ps-grab

Dacă doriți să rulați ceva de genul asta :

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

--

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

Sau ceva de genul :

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

Puteți ajunge argumente în linia de comandă, folosind sistemul.args`. Si eu folosesc solutia de mai jos pentru a analiza argumentele într-un obiect, astfel încât nu pot obține ceea ce vreau de nume.

var system = require('system');

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

acum nu't trebuie să știți indicele de argument. folositi-l ca args.orice

Notă: trebuie să utilizați nume argumente de genul file.js x=1 y=2 pentru a utiliza această soluție.

Puteți analiza toate argumentele și verificați dacă acestea există.

fișier: 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;
}

Decât să faci:

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