Ich habe einen Webserver in Node.js geschrieben und möchte mit einem bestimmten Ordner starten. Ich bin nicht sicher, wie ich auf Argumente in JavaScript zugreifen kann. Ich führe Knoten so aus:
$ node server.js folder
hier ist server.js
mein Servercode. Node.js help sagt, dass dies möglich ist:
$ node -h
Usage: node [options] script.js [arguments]
Wie würde ich auf diese Argumente in JavaScript zugreifen? Irgendwie konnte ich diese Informationen nicht im Internet finden.
Die Argumente werden in process.argv
gespeichert.
Hier sind der Knoten docs zur Behandlung von Kommandozeilenargen:
process.argv
ist ein Array, das die Befehlszeilenargumente enthält. Das erste Element ist 'node', das zweite Element ist der Name der JavaScript-Datei. Die nächsten Elemente sind zusätzliche Befehlszeilenargumente.
// 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 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' }
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']
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.
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"
Funktioniert hervorragend, um Optionen, Aktionen und Argumente zu definieren. Es generiert auch die Hilfeseiten für Sie.
Funktioniert hervorragend, um vom Benutzer Eingaben zu erhalten, wenn Sie den Callback-Ansatz mögen.
Funktioniert hervorragend, um vom Benutzer Eingaben zu erhalten, wenn Sie den Generatoransatz mögen.
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
}
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
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.
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' ]
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)
eingang
node test.js -D --name=Hello
ausgabe
{ D: true, name: 'Hello' }
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' }
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' }
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
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]
.
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"
}