Come posso passare gli argomenti della riga di comando a un programma Node.js?

Ho un server web scritto in Node.js e vorrei avviare con una cartella specifica. Non sono sicuro di come accedere agli argomenti in JavaScript. Sto usando un nodo come questo:

$ node server.js folder 

qui server.js è il mio codice server. L’aiuto di Node.js dice che questo è ansible:

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

Come potrei accedere a quegli argomenti in JavaScript? In qualche modo non sono stato in grado di trovare queste informazioni sul web.

Metodo standard (senza libreria)

Gli argomenti sono memorizzati in process.argv

Ecco i documenti del nodo sulla gestione degli argomenti della riga di comando:

process.argv è una matrice contenente gli argomenti della riga di comando. Il primo elemento sarà ‘nodo’, il secondo elemento sarà il nome del file JavaScript. Gli elementi successivi saranno gli argomenti aggiuntivi della riga di comando.

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

Questo genererà:

 $ 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 

Per normalizzare gli argomenti come una normale funzione javascript, lo faccio nei miei script della shell node.js:

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

Si noti che il primo argomento è in genere il percorso per nodejs e il secondo argomento è la posizione dello script che si sta eseguendo.

La risposta giusta aggiornata per questo per usare la libreria minimista . Usavamo node-optimist, ma da allora è stato deprecato.

Ecco un esempio di come utilizzarlo preso direttamente dalla documentazione 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' } 

Risposta del 2018 basata sulle tendenze attuali in natura:


Argomento dell’argomento di vanilla javascript:

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

Questo restituisce:

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

Documenti ufficiali


Pacchetti NPM più utilizzati per l’analisi degli argomenti:

Minimista : per l’analisi minima degli argomenti.

Commander.js : il modulo più utilizzato per l’analisi degli argomenti.

Meow : alternativa più leggera a Commander.js

Yargs : argomentazione più sofisticata dell’argomento (pesante).

Vorpal.js : applicazioni a linea di comando mature / interattive con analisi degli argomenti.

Optimist (ottimista dei nodes)

Scopri la libreria di ottimisti , è molto meglio dell’analisi a mano delle opzioni della riga di comando.

Aggiornare

Optimist è deprecato. Prova yargs che è un fork of optimist attivo.

Diverse grandi risposte qui, ma tutto sembra molto complesso. Questo è molto simile al modo in cui gli script di bash accedono ai valori degli argomenti ed è già fornito standard con node.js come indicato da MooGoo. (Giusto per renderlo comprensibile a qualcuno che è nuovo a node.js)

Esempio:

 $ 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

Funziona alla grande per la definizione di opzioni, azioni e argomenti. Genera anche le pagine di aiuto per te.

prontamente

Funziona alla grande per ricevere input dall’utente, se ti piace l’approccio di callback.

Co-Prompt

Funziona alla grande per ottenere input dall’utente, se ti piace l’approccio del generatore.

Biblioteca Stdio

Il modo più semplice per analizzare gli argomenti della riga di comando in NodeJS è l’utilizzo del modulo stdio . Ispirato dall’utilità getopt UNIX, è così banale come segue:

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

Se esegui il codice precedente con questo comando:

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

Quindi l’object ops sarà il seguente:

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

Quindi puoi usarlo come vuoi. Per esempio:

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

Sono supportate anche le opzioni raggruppate, quindi puoi scrivere -om invece di -o -m .

Inoltre, stdio può generare automaticamente un output di aiuto / utilizzo. Se chiami ops.printHelp() otterrai quanto segue:

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

Il messaggio precedente viene mostrato anche se non viene fornita un’opzione obbligatoria (preceduta dal messaggio di errore) o se è stata specificata (ad esempio, se si specifica un singolo argomento per un’opzione e se ne richiede 2).

È ansible installare il modulo stdio utilizzando NPM :

 npm install stdio 

Se il tuo script è chiamato myScript.js e vuoi passare il nome e il cognome, “Sean Worthington”, come argomenti come di seguito:

 node myScript.js Sean Worthington 

Quindi all’interno del tuo script scrivi:

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

command-line-args vale la pena dare un’occhiata!

È ansible impostare le opzioni utilizzando gli standard di notazione principale ( ulteriori informazioni ). Questi comandi sono tutti equivalenti, impostando gli stessi 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 

Per accedere ai valori, innanzitutto creare un elenco di definizioni di opzioni che descrivono le opzioni accettate dall’applicazione. La proprietà type è una funzione setter (il valore fornito viene passato attraverso questo), dandoti il ​​pieno controllo sul valore ricevuto.

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

Successivamente, analizza le opzioni usando commandLineArgs () :

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

options ora assomigliano a questo:

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

Utilizzo avanzato

Oltre all’utilizzo tipico sopra descritto, è ansible configurare gli argomenti della riga di comando per accettare forms di syntax più avanzate.

Sintassi basata su comando (stile git) nel modulo:

 $ executable  [options] 

Per esempio.

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

Sintassi dei comandi e dei sottocomandi (stile finestra mobile) nel modulo:

 $ executable  [options]  [options] 

Per esempio.

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

Generazione guida di utilizzo

Una guida all’utilizzo (tipicamente stampata quando è impostata l’ --help ) può essere generata utilizzando l’utilizzo della riga di comando . Vedere gli esempi qui sotto e leggere la documentazione per le istruzioni su come crearli.

Un tipico esempio di guida all’utilizzo.

uso

La guida all’uso di polymer-cli è un buon esempio di vita reale.

uso

Ulteriori letture

C’è molto altro da imparare, per favore vedi il wiki per esempi e documentazione.

C’è un’app per questo. Bene, modulo. Bene, più di uno, probabilmente centinaia.

Yargs è uno dei più divertenti, i suoi documenti sono fantastici da leggere.

Ecco un esempio dalla pagina github / npm:

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

L’output è qui (legge le opzioni con trattini, ecc., Brevi e lunghi, numerici, ecc.).

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

Probabilmente è una buona idea gestire la tua configurazione in modo centralizzato usando qualcosa come nconf https://github.com/flatiron/nconf

Ti aiuta a lavorare con i file di configurazione, le variabili di ambiente, gli argomenti della riga di comando.

Passare, analizzare gli argomenti è un processo facile. Il nodo fornisce la proprietà process.argv, che è una matrice di stringhe, che sono gli argomenti utilizzati quando è stato richiamato il nodo. La prima voce dell’array è l’eseguibile del nodo e la seconda è il nome del tuo script.

Se si esegue lo script con i seguenti documenti

 $ node args.js arg1 arg2 

File: args.js

 console.log(process.argv) 

Riceverai array come

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

senza librairie: utilizzando Array.prototype.reduce ()

 const args = process.argv.slice(2).reduce((acc, arg) => { let [k, v = true] = arg.split('=') acc[k] = v return acc }, {}) 

per questo comando node index.js count=2 print debug=false msg=hi

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

anche,

possiamo cambiare

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

da (molto più a lungo)

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

per auto parse Boolean & Number

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

È ansible analizzare tutti gli argomenti e verificare se esistono.

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

Non fare semplicemente:

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

Se vuoi eseguire qualcosa del genere:

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

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

O qualcosa come:

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

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

Puoi raggiungere gli argomenti della riga di comando usando system.args . E io uso la soluzione seguente per analizzare gli argomenti in un object, quindi posso ottenere quale voglio per nome.

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

ora non è necessario conoscere l’indice dell’argomento. args.whatever come args.whatever

Nota: è necessario utilizzare argomenti denominati come file.js x=1 y=2 per utilizzare questa soluzione.

proj.js

 for(var i=0;i 

Terminale:

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

Risultato:

 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. 

spiegazione:

0 : La directory di node.exe nel tuo maching (C: \ Programmi \ nodejs \ node.exe ')

1 : La directory del tuo file di progetto. (proj.js)

2 : Il tuo primo argomento al nodo (arg1)

3 : Il tuo secondo argomento su node (arg2)

4 : Il tuo terzo argomento su node (arg3)

i tuoi argomenti attuali iniziano con il 2nd indice dell'array argv , che è process.argv[2] .

Ecco la mia soluzione 0-dep per gli argomenti con nome:

 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) 

Esempio:

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

Nota: naturalmente questo fallirà quando l’argomento contiene a = . Questo è solo per un utilizzo molto semplice.

Senza librerie

Se vuoi farlo con vanilla JS / ES6 puoi usare la seguente soluzione

ha funzionato solo in 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; }, {}); 

E questo comando

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

produrrà il seguente risultato

 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 Si prega di correggere il codice nella mappa e ridurre la funzione se si trova una soluzione più elegante, grazie;)

Il modo più semplice per recuperare argomenti in Node.js è tramite l’array process.argv. Questo è un object globale che puoi usare senza importare librerie aggiuntive per usarlo. È sufficiente passare argomenti a un’applicazione Node.js, proprio come abbiamo mostrato in precedenza, e questi argomenti sono accessibili dall’applicazione tramite l’array process.argv.

Il primo elemento dell’array process.argv sarà sempre un percorso del file system che punta all’eseguibile del nodo. Il secondo elemento è il nome del file JavaScript che viene eseguito. E il terzo elemento è il primo argomento che è stato effettivamente passato dall’utente.

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

Tutto questo script fa un ciclo attraverso l’array process.argv e stampa gli indici, insieme agli elementi memorizzati in quegli indici. È molto utile per il debug se hai dubbi su quali argomenti stai ricevendo e in quale ordine.

Puoi anche usare librerie come yargs per lavorare con argomenti di commnadline.

come indicato nei documenti del nodo La proprietà process.argv restituisce un array contenente gli argomenti della riga di comando passati al momento dell’avvio del processo Node.js.

Ad esempio, assumendo il seguente script per process-args.js:

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

Avvio del processo Node.js come:

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

Genererebbe l’uscita:

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

La maggior parte delle persone ha dato buone risposte. Vorrei anche contribuire con qualcosa qui. Sto fornendo la risposta usando la libreria lodash per scorrere tutti gli argomenti della riga di comando che passiamo mentre lodash l’app:

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

Per eseguire il codice sopra, esegui solo i seguenti comandi:

 npm install node index.js xyz abc 123 456 

Il risultato sarà:

 xyz abc 123 456 

process.argv è tuo amico, l’acquisizione di argomenti da riga di comando è supportata nativamente in Node JS. Vedi esempio sotto ::

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

Puoi anche usare il pacchetto yargs per rendere la cosa molto più semplice! ecco qua 🙂 Yargs

Un semplice frammento se ce n’è bisogno:

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