it-swarm.com.de

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

2016
milkplus

Standardmethode (keine Bibliothek)

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
2660
MooGoo

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.

549
Mauvis Ledford

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

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.

253
dthree

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.

114
gor

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"
82
Kalemanzi

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.

70
balupton

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
41
sgmonda

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

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.

usage

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

usage

Lesen Sie weiter

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

23
Lloyd

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

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' }
13
Michael Warner

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

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.

10
250R

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']
9
Piyush Sagar

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.

9
grebenyuksv
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'
7
Abdennour TOUMI

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.

6
Evren Kutar

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']);
6
Amadu Bah

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

5
Nouman Dilshad

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

4
Cassidy

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.

3
Rubin bhandari

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.

1
Akshay Rajput

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
0
S.Mishra

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 .

0
madhur acharya

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
0

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

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