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.

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

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.

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

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.

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.

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"

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.

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

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

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'

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.

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

Ulteriori letture

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

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

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.

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

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

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

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'

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

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

È 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']);

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

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

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

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.

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

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

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

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

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 .

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