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


2417

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

$ node server.js folder

ecco il server.jsmio codice server. La guida di Node.js dice che questo è possibile:

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

Risposte:


3048

Metodo standard (nessuna libreria)

Gli argomenti sono memorizzati in process.argv

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

process.argvè un array che contiene gli argomenti della riga di comando. Il primo elemento sarà 'nodo', il secondo elemento sarà il nome del file JavaScript. I prossimi elementi saranno eventuali argomenti della riga di comando aggiuntivi.

// 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

7
Cosa devo digitare nel prompt dei comandi per eseguire uno script node.js con argomenti da riga di comando?
Anderson Green,

8
AGGIORNAMENTO: ho trovato la risposta alla domanda sopra. stackoverflow.com/questions/12925802/…
Anderson Green,

2
Il minimista è un analizzatore di argomenti semplice e grande
Guilherme Nagatomo,

4
Puoi anche accedere a un singolo argomento quando conosci la sua posizione: process.argv[n]dov'è nl'indice a base zero
Luca Steeb,

6
il secondo elemento (process.argv [1]) può essere o non essere un file js. la sintassi del comando node è node [options] [ -e script | script.js ] [arguments]o node debug script.js [arguments]. per esempio: node --harmony script.js balalaoppure node --no-deprecation --enable-ssl2 script.js balala, possiamo usare process.execArgv con process.argv
cuixiping

679

Per normalizzare gli argomenti come riceverebbe una normale funzione JavaScript, lo faccio negli script della shell node.js:

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

Nota che il primo arg è di solito il percorso di nodejs e il secondo arg è la posizione dello script che stai eseguendo.


19
Solo una nota che ho scritto questa risposta 4 anni fa e il codice che sto correndo funziona ancora bene al 100% oggi. Sempre aggiornato sulle ultime versioni del nodo e ancora zero problemi: è solo un semplice script di shell ragazzi. Non fa parte di un grande oggetto globale pieno di librerie JS. Sono ancora dietro la mia risposta oggi. Darò un altro aggiornamento tra altri 4 anni.
Mauvis Ledford,

36
@cuixiping ma la execArgvsono non nel argvmodo che il 2 è sufficiente
Tommi Kyntola

7
Dopo aver esaminato la cronologia delle modifiche di questa risposta, vorrei prendere un momento per simpatizzare con @MauvisLedford. Non c'è nulla di così fastidioso come modifiche indesiderate al tuo codice in nome delle preferenze personali (senza vantaggi quantificabili, da avviare). A chi lo fa: buttare via.
Jonathan Dumaine,

7
Ehi @MauvisLedford sono passati altri quattro anni. Mi piacerebbe un aggiornamento!
andrew lorien

13
NONprocess.argv.splice(process.execArgv.length + 2) : per un comando node --harmony script.js --version, process.argvè ['/usr/local/bin/node', 'script.js', '--version']. Le bandiere nonnode sono incluse in ! process.argv
Константин Ван,

360

La risposta giusta aggiornata per questo è usare la libreria minimista . Abbiamo usato per usare il nodo-ottimista , ma da allora è stato deprecato.

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

32
In realtà, questa soluzione è più utile per lo sviluppo dello strumento da riga di comando con più flag e argomenti, e dovrebbe essere votato più IMHO.
JK ABC

2
Imo, questa è un'alternativa più semplice a npmjs.com/package/command-line-args
klodoma,

5
@JKABC Non chiamerei questa la risposta più corretta, poiché l'OP chiede solo di accedere a informazioni banali da riga di comando. Ma sono d'accordo sul fatto che entrambi gli argomenti minimist e command-line sono molto utili se hai intenzione di estendere la tua CLI.
Justus Romijn,

2
Mi chiedo perché '-n5' non produca 'n5: true' - questo avrebbe senso per me.
Max Waterman,

7
@MaxWaterman: perché le opzioni che iniziano con un singolo trattino sono solo per un singolo personaggio. Tutto ciò che segue una singola opzione char viene considerato come argomento per l'opzione (non è richiesto spazio). L'avvio dell'opzione con due trattini (cioè --n5) dovrebbe produrre 'n5: true'. Questo è un comportamento abbastanza standard per la maggior parte degli strumenti da riga di comando Unix (ma sfortunatamente non tutti).
Menno Smits

313

Risposta 2018 basata sulle tendenze attuali in natura:


Analisi dell'argomento javascript alla vaniglia:

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

Questo ritorna:

$ 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 : modulo più adottato per l'analisi degli argomenti.

Meow : alternativa più leggera a Commander.js

Yargs : analisi degli argomenti più sofisticata (pesante).

Vorpal.js : applicazioni da riga di comando mature / interattive con analisi degli argomenti.


76
"$ npm install -g yargs" ha prodotto 1,9 MB di codice JavaScript. Quando finirà questa follia quando una libreria di parser argv ha bisogno di due megabyte di codice? Aumento della superficie di attacco, spreco di RAM ecc ...
joonas.fi,

9
Yargs è uno strumento più grande che capita anche di analizzare gli argomenti della riga di comando. Nessuna follia, solo mancanza di informazioni. Se vuoi qualcosa di più leggero, usa il JS grezzo, Meow o Minimist.
3

1
"$ npm i yargs" -> 800 KB qui, immagino che i proprietari dei pacchetti abbiano finalmente imparato a ignorare i file non pertinenti. Comunque, ancora grande per progetti sciocchi, ma piccolo quando hai bisogno di robustezza e su progetti più grandi hai già dipendenze ..
Andre Figueiredo

3
Ho creato un pacchetto, chiamato wily-cli , con l'obiettivo di rendere uno strumento più potente, più personalizzabile e più facile da usare rispetto ai grandi nomi elencati. Per quelli di voi che sono interessati, sono solo 94.6 KB al momento dell'installazione
Jason

1
vscode import-cost mi dice che yargs (159.2K) ora è in realtà più leggero di meow (180.2K). Minimist li batte ancora a 3.4K!
Shivam Tripathi,

124

Optimist (ottimista nodo)

Dai un'occhiata alla libreria optimist , è molto meglio che analizzare manualmente le opzioni della riga di comando.

Aggiornare

Optimist è obsoleto. Prova yargs che è un fork attivo di ottimista.


18
+1 per il collegamento. C'è un lungo elenco di parser di opzioni della riga di comando su github.com/joyent/node/wiki/modules#wiki-parsers-commandline
Thilo

7
Minimist è un altro successore dell'ottimista ormai deprecato. È "il coraggio del parser dell'ottimista senza tutta la fantasia fantasiosa". 23 milioni di download nell'ultimo mese (al 12/2015).
aap il

96

Diverse ottime risposte qui, ma sembra tutto molto complesso. Questo è molto simile al modo in cui gli script bash accedono ai valori degli argomenti ed è già fornito standard con node.js come ha sottolineato MooGoo. (Solo per renderlo comprensibile a qualcuno che è nuovo su 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"

80

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 ottenere 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.


26
@Evan Carroll, per favore non modificare la mia risposta per promuovere una libreria Non uso stackoverflow.com/posts/7483600/revisions soprattutto a causa di una caratteristica mancante che stai cercando, tali opinioni dovrebbero essere salvate per commenti o richieste pull gli autori del modulo, non le modifiche alle risposte degli altri.
Balupton,

Commander.js mi ha davvero aiutato. Altre librerie non funzionerebbero con il compilatore Nexe ma questo fa il trucco. Se vuoi ottenere args quando usi nexe, assicurati di passare -f al compilatore nexe.
pierce.jason,

60

Nessun lib con bandiere formattate in un oggetto semplice

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

Esempi

Semplice

ingresso

node test.js -D --name=Hello

produzione

{ D: true, name: 'Hello' }

Mondo reale

ingresso

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

produzione

{ 
  l: true,
  H: true,
  R: true,
  s: true,
  ip: '127.0.0.1',
  port: '8080',
  env: 'dev'
}

1
Dal momento che alcune bandiere hanno una forma lunga, potresti spiegarlo. Invece di = longArg[1]te potresti scrivere = longArg.length > 1 ? longArg[1] : true;Questo ti permetterebbe di passare questo tipo di argomento:node config/build.js --flag1 --flag2
Tralston,

Mi piace. Ha reso la linea un po 'lunga, quindi l'ho rotta. Grazie per avermelo detto.
Michael Warner,

54

Biblioteca Stdio

Il modo più semplice per analizzare gli argomenti della riga di comando in NodeJS è usare il modulo stdio . Ispirato getoptdall'utilità UNIX , è 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, required: true},
    'ooo': {key: 'o'}
});

Se si esegue il codice precedente con questo comando:

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

Quindi l' opsoggetto 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 -ominvece di -o -m.

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

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

Il messaggio precedente viene visualizzato anche se non viene fornita un'opzione obbligatoria (preceduta dal messaggio di errore) o se non è specificata correttamente (ad esempio, se si specifica un singolo argomento per un'opzione e necessita di 2).

Puoi installare il modulo stdio usando NPM :

npm install stdio

3
Per quanto riguarda i TOS di SO, vale la pena ricordare che @sgmonda è l'unico manutentore del modulo;) Piccolo modulo carino, comunque. Decisamente utile
Qix - MONICA È STATA MISTREATA il

1
Anzi utile, anche se l'aggiornamento più recente è stato il 30 dicembre 2014. Potrebbe non essere mantenuto come alcuni altri pacchetti.
fearless_fool il

bella lib! tks! nonostante sia senza aggiornamenti recenti .. Ha abbastanza buone funzionalità
Pablo Ezequiel

È passato un po 'di tempo ma ho appena rilasciato la versione 2, con pieno supporto e supporto dattiloscritto. :-)
sgmonda

47

Se il tuo script si chiama myScript.js e desideri passare il nome e il cognome "Sean Worthington", come argomenti come di seguito:

node myScript.js Sean Worthington

Quindi nella tua sceneggiatura scrivi:

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

28

la riga di comando-args vale la pena dare un'occhiata!

È possibile impostare le opzioni utilizzando gli standard di notazione principali ( 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, creare innanzitutto un elenco di definizioni delle opzioni che descrivono le opzioni accettate dall'applicazione. La typeproprietà è 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 si presenta così:

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

Utilizzo avanzato

Oltre all'utilizzo tipico sopra, è possibile configurare la riga di comando-args per accettare moduli di sintassi più avanzati.

Sintassi basata su comandi (stile git) nel modulo:

$ executable <command> [options]

Per esempio.

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

Sintassi dei comandi e dei sotto-comandi (stile docker) nel formato:

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

Per esempio.

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

Generazione della guida all'uso

Una guida all'uso (in genere stampata quando --helpè impostata) può essere generata utilizzando l'utilizzo della riga di comando . Vedi gli esempi seguenti e leggi la documentazione per istruzioni su come crearli.

Un tipico esempio di guida all'uso.

uso

La guida all'uso di polimero-cli è un buon esempio di vita reale.

uso

Ulteriori letture

C'è molto altro da imparare, consultare la wiki per esempi e documentazione.


@Lloyd questo è collegato al problema già sorto - qui . Webstorm passa alcuni argomenti aggiuntivi.
kboom,

@kboom il problema è stato risolto dalle opzioni partiale stopAtFirstUnknown. Vedi i documenti .
Lloyd,

23

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

Yargs è uno di quelli divertenti, i suoi documenti sono belli 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' ]

21

Ecco la mia soluzione 0-dep per 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: questo naturalmente fallirà quando l'argomento contiene a =. Questo è solo per un utilizzo molto semplice.


12

È 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 file di configurazione, variabili di ambiente, argomenti della riga di comando.


Ed ecco la configurazione , la mia, minima, interfaccia di sola lettura per nconf.
Joel Purra,

12

senza librerie: usando 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

di (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 analizzare automaticamente Boolean & Number

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

La versione più lunga ha un problema con le stringhe che contengono punti.
Berlino,

Soluzione intelligente! Che cosa devo fare per supportare sia counte cle opzioni della riga di comando ( ccome alias / scorciatoia per count)?
Alex Vang,

Questo è bellissimo! Ma non utilizza lo standard "un trattino per una chiave di lettera e due trattini per chiave di parola". Sfortunatamente, la mia alternativa è troppo lunga e brutta da pubblicare qui, quindi aggiungerò una risposta diversa.
Isacvale,

10

Passare, analizzare gli argomenti è un processo semplice. Node fornisce la proprietà process.argv, che è un array di stringhe, che sono gli argomenti utilizzati quando è stato invocato Node. La prima voce dell'array è l'eseguibile Nodo e la seconda voce è il nome dello script.

Se si esegue uno script con gli strumenti seguenti

$ node args.js arg1 arg2

File: args.js

console.log(process.argv)

Otterrai array come

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

9
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 del genere:

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

-

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

1
Questo repository non è più disponibile su github.
steadweb,

8

proj.js

for(var i=0;i<process.argv.length;i++){
  console.log(process.argv[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 computer (C: \ Programmi \ nodejs \ node.exe ')

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

2 : Il tuo primo argomento al nodo (arg1)

3 : Il tuo secondo argomento al nodo (arg2)

4 : Il tuo terzo argomento al nodo (arg3)

i tuoi argomenti effettivi iniziano 2nddall'indice argvdell'array, ovvero process.argv[2].


7

È possibile raggiungere gli argomenti della riga di comando utilizzando system.args. E io uso la soluzione qui sotto per analizzare gli argomenti in un oggetto, così posso ottenere quello che 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. usalo comeargs.whatever

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


Non riesco a farlo funzionare, la mapproprietà non è definita.
caram

6

È possibile analizzare tutti gli argomenti e verificare se esistono.

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

Di fare semplicemente:

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

4

Senza biblioteche

Se vuoi farlo in 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 Correggi il codice nella mappa e riduci la funzione se trovi una soluzione più elegante, grazie;)


1
sono d'accordo, ma potrebbe essere più breve no? let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})
Joseph Merdrignac,

4

Sebbene le risposte di cui sopra siano perfette e qualcuno abbia già suggerito degli yarg, usare il pacchetto è davvero semplice. Questo è un bel pacchetto che rende davvero semplice passare argomenti alla riga di comando.

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

Per ulteriori informazioni, visitare https://yargs.js.org/ .


Yargs non influenza il modo in cui gli argomenti vengono passati sulla riga di comando, aiuta solo a leggerli nel codice.
user3285954,

4

Passare gli argomenti è facile e riceverli è solo una questione di lettura del processo.array array Il nodo rende accessibile da qualsiasi luogo, in pratica. Ma sicuramente vorrai leggerli come coppie chiave / valore, quindi avrai bisogno di un pezzo da scrivere per interpretarlo.

Joseph Merdrignac ne ha pubblicato uno bello usando la riduzione, ma si basava su una key=valuesintassi invece di -k valuee --key value. L'ho riscritto molto più brutto e più a lungo per usare quel secondo standard, e lo posterò come una risposta perché non si adatterebbe come un commento. Ma ottiene il lavoro fatto.

   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
   },{})

Con questo codice un comando node script.js alpha beta -charlie delta --echo foxtrotti darebbe il seguente oggetto


args = {
 "alpha":true,
 "beta":true,
 "c":true,
 "h":true,
 "a":true,
 "r":true
 "l":true,
 "i":true,
 "e":"delta",
 "echo":"foxtrot"
}

3

Il modo più semplice per recuperare argomenti in Node.js è tramite l'array process.argv. Questo è un oggetto globale che puoi usare senza importare librerie aggiuntive per usarlo. Devi semplicemente passare gli argomenti a un'applicazione Node.js, proprio come abbiamo mostrato in precedenza, e questi argomenti sono accessibili all'interno dell'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 ciò che fa questo script è scorrere l'array process.argv e stampare gli indici, insieme agli elementi memorizzati in quegli indici. È molto utile per il debug se hai mai domande su quali argomenti stai ricevendo e in quale ordine.

Puoi anche usare librerie come yargs per lavorare con argomenti comuni.


2

Soluzione TypeScript senza librerie:

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

Ingresso: ts-node index.js -p param --parameter parameter

Produzione: { p: 'param ', parameter: 'parameter' }


1

process.argvè tuo amico, catturare arg dalla riga di comando è nativamente supportato in Node JS. Vedi esempio di seguito ::

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

0

come indicato nei documenti del nodo La proprietà process.argv restituisce un array contenente gli argomenti della riga di comando passati all'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'output:

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

0

La maggior parte delle persone ha dato buone risposte. Vorrei anche contribuire qualcosa qui. Sto fornendo la risposta utilizzando la lodashlibreria per scorrere tutti gli argomenti della riga di comando che passiamo all'avvio dell'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 basta eseguire i seguenti comandi:

npm install
node index.js xyz abc 123 456

Il risultato sarà:

xyz 
abc 
123
456

0

Il modo migliore per passare argomenti della riga di comando a un programma Node.js è utilizzare un'interfaccia della riga di comando (CLI)

Esiste un elegante modulo npm chiamato nodejs-cli che puoi usare.

Se vuoi crearne uno senza dipendenze ne ho uno sul mio Github se vuoi verificarlo, in realtà è abbastanza semplice e facile da usare, fai clic su qui .


0

Soluzione senza dipendenze in stile 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());
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.