Wie übergebe ich Befehlszeilenargumente an ein Node.js-Programm?

Um die Argumente zu normalisieren, die eine normale Javascript-Funktion erhalten würde, mache ich dies in meinen node.js-Shell-Skripten:

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

Beachten Sie, dass das erste Argument normalerweise der Pfad zu nodejs ist und das zweite Argument die Position des Skripts, das Sie ausführen.

Die aktuellen right antworten darauf, um die minimist library zu verwenden. Früher haben wir node-optimist verwendet, aber es ist inzwischen veraltet. 

Hier ein Beispiel, wie man es direkt aus der Dokumentation des Minimisten verwendet:

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

Antwort von 2018 basierend auf aktuellen Trends in freier Wildbahn:

Vanilla Javascript Argument Parsing:

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

Dies gibt zurück:

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

Offizielle Dokumente

Die am häufigsten verwendeten NPM-Pakete für die Argumentanalyse:

Minimist: Für minimales Argument-Parsing.

Commander.js: Das meist verwendete Modul für die Argumentanalyse.

Meow: Leichtere Alternative zu Commander.js

Yargs: Raffinierteres Argument-Parsing (schwer).

Vorpal.js: Ältere/interaktive Befehlszeilenanwendungen mit Argumentanalyse.

Optimist (Knotenoptimist)

Check out optimist library , es ist viel besser, als Befehlszeilenoptionen von Hand zu analysieren.

Update

Optimist ist veraltet. Versuchen Sie yargs , was eine aktive Gabelung des Optimisten ist.

Hier gibt es einige großartige Antworten, aber es scheint alles sehr komplex zu sein. Dies ähnelt sehr dem Zugriff von bash-Skripts auf Argumentwerte und es ist bereits standardmäßig mit node.js versehen, wie MooGoo darauf hinweist .. (Nur um es für jemanden verständlich zu machen, der neu in node.js ist)

Beispiel:

$ 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

Funktioniert hervorragend, um Optionen, Aktionen und Argumente zu definieren. Es generiert auch die Hilfeseiten für Sie.

Prompt

Funktioniert hervorragend, um vom Benutzer Eingaben zu erhalten, wenn Sie den Callback-Ansatz mögen.

Co-Prompt

Funktioniert hervorragend, um vom Benutzer Eingaben zu erhalten, wenn Sie den Generatoransatz mögen.

Stdio-Bibliothek

Die einfachste Methode zum Analysieren von Befehlszeilenargumenten in NodeJS ist die Verwendung des Moduls stdio . Inspiriert durch das UNIX-Dienstprogramm getopt ist es so einfach wie folgt:

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

Wenn Sie den vorherigen Code mit diesem Befehl ausführen:

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

Das ops-Objekt wird dann wie folgt aussehen:

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

So können Sie es verwenden, wie Sie möchten. Zum Beispiel:

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

Gruppierte Optionen werden ebenfalls unterstützt, sodass Sie anstelle von -om-o -m schreiben können.

Außerdem kann stdio automatisch eine Hilfe/Verwendungsausgabe generieren. Wenn Sie ops.printHelp() aufrufen, erhalten Sie Folgendes:

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

Die vorherige Nachricht wird auch angezeigt, wenn keine obligatorische Option angegeben ist (vorangestellt wird die Fehlernachricht) oder wenn sie falsch angegeben ist (wenn Sie z. B. ein einzelnes Argument für eine Option angeben und 2 benötigen).

Sie können stdio module mit NPM installieren:

npm install stdio

Wenn Ihr Skript myScript.js heißt und Sie den Vor- und Nachnamen "Sean Worthington" als Argumente wie folgt übergeben möchten:

node myScript.js Sean Worthington

Dann schreiben Sie in Ihrem Skript:

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

command-line-args ist einen Blick wert!

Sie können Optionen mithilfe der Hauptnotationsstandards einstellen ( Weitere Informationen ). Diese Befehle sind alle gleichwertig und setzen dieselben Werte:

$ 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

Um auf die Werte zuzugreifen, erstellen Sie zuerst eine Liste von Optionsdefinitionen , die die Optionen beschreiben, die Ihre Anwendung akzeptiert. Die type -Eigenschaft ist eine Setter-Funktion (der übergebene Wert wird durch diese übergeben), wodurch Sie die volle Kontrolle über den erhaltenen Wert haben.

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

Als nächstes analysieren Sie die Optionen mit commandLineArgs () :

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

options sieht jetzt so aus:

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

Erweiterte Nutzung

Neben der obigen typischen Verwendung können Sie Befehlszeilenargumente so konfigurieren, dass erweiterte Syntaxformulare akzeptiert werden.

Befehlsbasierte Syntax (git style) in der Form:

$ executable <command> [options]

Zum Beispiel.

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

Befehls- und Unterbefehlssyntax (Docker-Stil) in der Form:

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

Zum Beispiel.

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

Generierung von Nutzungshinweisen

Ein Verwendungshandbuch (normalerweise gedruckt, wenn --help eingestellt ist) kann mit Befehlszeilenverwendung erstellt werden. Siehe die Beispiele unten und Lesen Sie die Dokumentation , um Anweisungen zu erhalten, wie Sie diese erstellen.

Ein typisches Anwendungsbeispiel.

Der polymer-cli usage guide ist ein gutes Beispiel aus der Praxis.

Lesen Sie weiter

Es gibt noch viel mehr zu lernen, siehe das Wiki für Beispiele und Dokumentation.

Dafür gibt es eine App. Nun, Modul. Nun, mehr als eine, wahrscheinlich Hunderte.

Yargs ist einer der lustigen, seine Dokumente sind cool zu lesen.

Hier ist ein Beispiel von der github/npm-Seite:

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

Ausgabe ist hier (liest Optionen mit Bindestrichen usw., kurz und lang, numerisch usw.).

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

Keine Libs mit Flags, die zu einem einfachen Objekt formatiert sind

function getArgs () {
  const args = {}
  process.argv
    .slice(2, process.argv.length)
    .forEach( arg => {
      // long arg
      if (arg.slice(0,2) === '--') {
        const longArg = arg.split('=')
        args[longArg[0].slice(2,longArg[0].length)] = longArg[1]
      }
     // 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)

Beispiele

Einfach

eingang

node test.js -D --name=Hello

ausgabe

{ D: true, name: 'Hello' }

Echte Welt

eingang

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

ausgabe

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

ohne librairies: mit Array.prototype.reduce ()

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

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

}, {})

für diesen Befehl node index.js count=2 print debug=false msg=hi

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

ebenfalls,

wir können es ändern 

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

von (viel länger)

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

boolean & Number automatisch parsen

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

Es ist wahrscheinlich eine gute Idee, Ihre Konfiguration zentral zu verwalten, beispielsweise mit nconfhttps://github.com/flatiron/nconf

Es hilft Ihnen bei der Arbeit mit Konfigurationsdateien, Umgebungsvariablen und Befehlszeilenargumenten.

Das Übergeben und Analysieren von Argumenten ist ein einfacher Prozess. Node stellt Ihnen die Eigenschaft process.argv zur Verfügung, bei der es sich um ein Array von Strings handelt. Dies sind die Argumente, die beim Aufruf von Node verwendet wurden. Der erste Eintrag des Arrays ist die ausführbare Datei des Knotens, und der zweite Eintrag ist der Name Ihres Skripts. 

Wenn Sie ein Skript mit den folgenden Argumenten ausführen

$ node args.js arg1 arg2

Datei: args.js

console.log(process.argv)

Sie werden Array wie bekommen

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

Hier ist meine 0-dep-Lösung für benannte 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)

Beispiel:

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

Hinweis: Natürlich schlägt dies fehl, wenn das Argument einen = enthält. Dies ist nur für eine sehr einfache Verwendung.

npm install ps-grab

Wenn Sie so etwas ausführen wollen:

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

-

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

Oder so etwas wie: 

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

-

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

Befehlszeilenargumente erreichen Sie mit system.args. Und ich benutze die Lösung unten, um Argumente in ein Objekt zu parsen, damit ich herausfinden kann, welche ich per Namen möchte.

var system = require('system');

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

jetzt müssen Sie den Index des Arguments nicht kennen. benutze es wie args.whatever

Hinweis: Sie sollten benannte Argumente wie file.js x=1 y=2 verwenden, um .__ zu verwenden. diese Lösung.

Sie können alle Argumente analysieren und prüfen, ob sie vorhanden sind. 

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

Dann mache einfach:

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

proj.js

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

Terminal:

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

Ergebnis:

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.

Erklärung:

0: Das Verzeichnis von node.exe in Ihrem Maching (C:\Programme\nodejs\node.exe ')

1: Das Verzeichnis Ihrer Projektdatei. (proj.js)

2: Ihr erstes Argument für den Knoten (arg1)

3: Ihr zweites Argument für den Knoten (arg2)

4: Ihr drittes Argument für den Knoten (arg3)

ihre eigentlichen Argumente beginnen mit dem 2nd-Index des argv-Arrays, dh process.argv[2].

Ohne Bibliotheken

Wenn Sie dies in Vanilla JS/ES6 tun möchten, können Sie die folgende Lösung verwenden

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

Und dieser Befehl

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

wird das folgende Ergebnis erzeugen

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. Bitte korrigieren Sie den Code in der Karte und reduzieren Sie die Funktion Wenn Sie eine elegantere Lösung finden, danke;)

Die einfachste Methode zum Abrufen von Argumenten in Node.js ist über das Array process.argv. Dies ist ein globales Objekt, das Sie verwenden können, ohne zusätzliche Bibliotheken zu importieren. Sie müssen einfach Argumente an eine Node.js-Anwendung übergeben, wie wir es bereits gezeigt haben, und auf diese Argumente kann innerhalb der Anwendung über das Array process.argv zugegriffen werden.

Das erste Element des Arrays process.argv ist immer ein Dateisystempfad, der auf die ausführbare Datei des Knotens verweist. Das zweite Element ist der Name der JavaScript-Datei, die gerade ausgeführt wird. Und das dritte Element ist das erste Argument, das vom Benutzer tatsächlich übergeben wurde.

'use strict';

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

Dieses Skript durchläuft nur das Array process.argv und druckt die Indizes zusammen mit den in diesen Indizes gespeicherten Elementen. Es ist sehr nützlich für das Debugging, wenn Sie jemals in Frage stellen, welche Argumente Sie in welcher Reihenfolge erhalten.

Sie können auch Bibliotheken wie yargs verwenden, um mit Kommandozeilenargumenten zu arbeiten.

Obwohl die obigen Antworten perfekt sind und jemand bereits Yargs vorgeschlagen hat, ist die Verwendung des Pakets sehr einfach ... Dies ist ein Nizza-Paket, das die Weitergabe von Argumenten an die Befehlszeile sehr einfach macht.

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

Bitte besuchen Sie https://yargs.js.org/ für weitere Informationen.

Die meisten Leute haben gute Antworten gegeben. Ich möchte hier auch etwas beitragen. Ich gebe die Antwort mit der lodash-Bibliothek, um alle Befehlszeilenargumente zu durchlaufen, die wir beim Starten der App übergeben:

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

Um den Code auszuführen, führen Sie einfach die folgenden Befehle aus:

npm install
node index.js xyz abc 123 456

Das Ergebnis wird sein:

xyz 
abc 
123
456

Befehlszeilenargumente können am besten an ein Node.js-Programm übergeben werden, indem eine Befehlszeilenschnittstelle (Command Line Interface, CLI) verwendet wird.

Es gibt ein schickes npm-Modul namens nodejs-cli , das Sie verwenden können.

Wenn Sie einen erstellen möchten, der keine Abhängigkeiten hat, habe ich einen auf meinem Github, wenn Sie es ausprobieren möchten. Es ist eigentlich ganz einfach und einfach zu bedienen, klicken Sie auf hier .

wie in den Knoten docs .__ angegeben. Die Eigenschaft process.argv gibt ein Array zurück, das die Befehlszeilenargumente enthält, die beim Start des Prozesses Node.js übergeben wurden.

Angenommen, das folgende Skript für process-args.js wird angenommen:

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

Starten des Node.js-Prozesses als:

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

Würde die Ausgabe erzeugen:

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

process.argv ist Ihr Freund. Die Erfassung von Befehlszeilenargen wird in Node JS nativ unterstützt. Siehe Beispiel unten:

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

Das Übergeben von Argumenten ist einfach, und das Empfangen von Argumenten ist nur eine Frage des Lesens des Prozesses. Der Array Node macht im Grunde von überall aus Zugriff. Sie sollten sie jedoch unbedingt als Schlüssel/Wert-Paare lesen. Sie benötigen daher ein Skript, um es zu interpretieren.

Joseph Merdrignac hat einen schönen Beitrag geschrieben, der die Verwendung von reduzierte verwendet, aber er verwendete eine key=value-Syntax anstelle von -k value und --key value. Ich habe es viel hässlicher und länger überarbeitet, um diesen zweiten Standard zu verwenden, und ich werde ihn als Antwort posten, da er nicht als Kommentar passen würde. Aber es erledigt die Arbeit.

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

Mit diesem Code würde ein Befehl node script.js alpha beta -charlie delta --echo foxtrot Ihnen folgendes Objekt geben

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