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

Ich habe einen Webserver in Node.js geschrieben und möchte mit einem bestimmten Ordner starten. Ich bin mir nicht sicher, wie ich auf Argumente in JavaScript zugreifen kann. Ich führe Knoten wie folgt aus:

$ node server.js folder 

Hier ist server.js mein server.js . Die Node.js-Hilfe sagt, das ist möglich:

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

Wie würde ich auf diese Argumente in JavaScript zugreifen? Irgendwie war ich nicht in der Lage, diese Informationen im Internet zu finden.

Standardmethode (keine Bibliothek)

Die Argumente werden in process.argv gespeichert

Hier sind die Node-Dokumente zur Handhabung von Befehlszeilenargumenten:

process.argv ist ein Array mit den Befehlszeilenargumenten. Das erste Element ist “Knoten”, das zweite Element ist der Name der JavaScript-Datei. Die nächsten Elemente werden zusätzliche Befehlszeilenargumente sein.

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

Dies wird erzeugen:

 $ 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 

Um die Argumente wie normale Javascript-functionen zu normalisieren, mache ich das in meinen node.js Shell-Skripten:

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

Beachten Sie, dass der erste Arg normalerweise der Pfad zu nodejs ist und der zweite arg der Speicherort des Skripts, das Sie ausführen.

Die aktuelle richtige Antwort dafür ist die Verwendung der Minimistenbibliothek . Früher haben wir den Knotenoptimierer verwendet, aber seither ist er veraltet.

Hier ist ein Beispiel, wie man es direkt aus der minimistischen Dokumentation 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' } 

2018 Antwort basierend auf aktuellen Trends in der Wildnis:


Vanille-Javascript-Argumentanalyse:

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

Das gibt zurück:

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

Offizielle Dokumente


Am häufigsten verwendete NPM-Pakete für die Analyse von Argumenten:

Minimist : Für minimale Argumentanalyse.

Commander.js : Am häufigsten verwendetes Modul zum Parsen von Argumenten.

Miau : Leichtere Alternative zu Commander.js

Yargs : Anspruchsvollere Argumentanalyse (schwer).

Vorpal.js : Ältere / interaktive Befehlszeilenanwendungen mit Parsing von Argumenten.

Optimist (Knotenoptimist)

Check out Optimist-Bibliothek , es ist viel besser als das Parsen von Befehlszeilenoptionen von Hand.

Aktualisieren

Optimist ist veraltet. Probieren Sie yargs aus, was eine aktive Verzweigung des Optimisten ist.

Mehrere gute Antworten hier, aber alles scheint sehr komplex. Dies ist sehr ähnlich wie Bash Skripte auf Argument Werte zugreifen und es ist bereits standardmäßig mit node.js zur Verfügung gestellt, wie MooGoo darauf hingewiesen. (Nur um es jemandem 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

functioniert hervorragend zum Definieren von Optionen, Aktionen und Argumenten. Es generiert auch die Hilfeseiten für Sie.

Sofort

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

Co-Eingabeaufforderung

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

Stdio-Bibliothek

Die einfachste Möglichkeit, Befehlszeilenargumente in NodeJS zu analysieren, ist die Verwendung des stdio- Moduls. Inspiriert von UNIX- getopt Dienstprogramm ist es so trivial 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  -c 23 45 --map -k 23 file1 file2 

Dann ops Objekt wird wie folgt sein:

 { 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 -om anstelle von -o -m schreiben können.

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

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

Die vorherige Nachricht wird auch angezeigt, wenn keine obligatorische Option angegeben wurde (der die Fehlermeldung vorausgeht) oder wenn sie falsch angegeben ist (wenn Sie beispielsweise ein einzelnes Argument für eine Option angeben und 2 benötigt).

Sie können das stdio- Modul 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' 

Kommandozeilenargumente sind einen Blick wert!

Sie können Optionen unter Verwendung der wichtigsten Notationsstandards festlegen ( weitere Informationen ). Diese Befehle sind alle äquivalent 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 zunächst eine Liste mit Optionsdefinitionen , die die von Ihrer Anwendung akzeptierten Optionen beschreibt. Die Eigenschaft type ist eine Setter-function (der übergebene Wert wird übergeben), wodurch Sie die volle Kontrolle über den erhaltenen Wert erhalten.

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

Analysieren Sie als Nächstes 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 komplexere Syntaxformulare akzeptiert werden.

Befehlsbasierte Syntax (Git Stil) in der Form:

 $ executable  [options] 

Beispielsweise.

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

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

 $ executable  [options]  [options] 

Beispielsweise.

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

Erstellung von Nutzungsrichtlinien

Eine Gebrauchsanleitung (die normalerweise gedruckt wird, wenn --help gesetzt ist) kann unter Verwendung der Befehlszeilennutzung erzeugt werden. Sehen Sie sich die folgenden Beispiele an und lesen Sie die Dokumentation, um zu erfahren, wie sie erstellt werden.

Ein typisches Anwendungsbeispiel.

Verwendung

Der Polymer-CLI- Anwendungsleitfaden ist ein gutes Beispiel aus der Praxis .

Verwendung

Weiterführende Literatur

Es gibt noch viel mehr zu lernen. Im Wiki finden Sie Beispiele und Dokumentationen.

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

Yargs ist einer der spaßigen, 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 (es 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' ] 

Es ist wahrscheinlich eine gute Idee, Ihre Konfiguration zentral zu verwalten, indem Sie etwas wie nconf https://github.com/flatiron/nconf verwenden

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

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

Wenn Sie ein Skript mit unter atguments ausführen

 $ node args.js arg1 arg2 

Datei: args.js

 console.log(process.argv) 

Sie werden Array wie erhalten

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

ohne Bibliotheken: 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 Befehlsknoten 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 zu analysieren

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

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

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

Als nur tun:

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

Wenn Sie so etwas ausführen möchten:

 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 etwas wie:

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

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

Sie können Befehlszeilenargumente mit system.args . Und ich benutze die Lösung unten, um Argumente in ein Objekt zu analysieren, so kann ich bekommen, welches ich mit dem Namen will.

 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. args.whatever es wie args.whatever

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

proj.js

 for(var i=0;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 Ihrer Anwendung (C: \ Programme \ nodejs \ node.exe ')

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

2 : Dein erstes Argument zu Knoten (arg1)

3 : Das zweite Argument zum Knoten (arg2)

4 : Dein drittes Argument zum Knoten (arg3)

Ihre eigentlichen Argumente beginnen mit dem 2nd Index von argv array, das ist process.argv[2] .

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: Dies wird natürlich fehlschlagen, wenn das Argument ein = enthält. Dies ist nur für eine sehr einfache Verwendung.

Ohne Bibliotheken

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

funktionierte 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 

ps Bitte korrigieren Sie den Code in der Karte und reduzieren Sie die function, wenn Sie eine elegantere Lösung finden, danke;)

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

Das erste Element des process.argv-Arrays ist immer ein Dateisystempfad, der auf den ausführbaren Knoten verweist. Das zweite Element ist der Name der JavaScript-Datei, die 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])); } 

Das gesamte Skript führt eine Schleife durch das process.argv-Array durch und gibt die Indizes zusammen mit den in diesen Indizes gespeicherten Elementen aus. Es ist sehr nützlich für das Debugging, wenn Sie sich fragen, welche Argumente Sie erhalten und in welcher Reihenfolge.

Sie können auch Bibliotheken wie yargs zum Arbeiten mit commnadline-Argumenten verwenden.

Wie in den Node-Dokumenten angegeben. Die process.argv-Eigenschaft gibt ein Array zurück, das die Befehlszeilenargumente enthält, die beim Start des Node.js-processes übergeben wurden.

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

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

Starten des Node.js-processes 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 

Die meisten Leute haben gute Antworten gegeben. Ich möchte hier auch etwas beitragen. Ich lodash die Antwort mit der lodash Bibliothek, um alle Befehlszeilenargumente zu durchlaufen, die wir beim Start 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 obigen Code auszuführen, führen Sie einfach folgende Befehle aus:

 npm install node index.js xyz abc 123 456 

Das Ergebnis wird sein:

 xyz abc 123 456 

process.argv ist Ihr Freund, Capture-Zeilenargumente werden nativ in Node JS unterstützt. Siehe Beispiel unten:

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

Sie können auch YARGS-Paket verwenden, es macht die Sache viel einfacher! hier gehst du 🙂 Yargs

Ein einfaches Snippet, wenn es nötig ist:

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