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 soll. Ich führe einen Knoten wie folgt aus:

$ node server.js folder

Hier server.jsist mein Servercode. Die Hilfe von Node.j sagt, dass dies möglich ist:

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

Wie würde ich in JavaScript auf diese Argumente zugreifen? Irgendwie konnte ich diese Informationen nicht im Web finden.

Standardmethode (keine Bibliothek)

Die Argumente werden in gespeichert process.argv

Hier sind die Knotendokumente zur Behandlung von Befehlszeilenargumenten:

process.argvist 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 erzeugt:

$ 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 reguläre Javascript-Funktion erhalten würde, mache ich dies in meinen Shell-Skripten node.js:

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

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

Die aktuell richtige Antwort darauf ist die Verwendung der Minimist- Bibliothek. Früher haben wir Node-Optimist verwendet, aber seitdem ist es veraltet.

Hier ist ein Beispiel für die Verwendung direkt aus der Minimist-Dokumentation:

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 2018 basierend auf aktuellen Trends in freier Wildbahn:

Analyse von Vanille-Javascript-Argumenten:

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 zum Parsen von Argumenten:

Minimist : Für minimales Parsen von Argumenten.

Commander.js : Das am häufigsten verwendete Modul für das Parsen von Argumenten.

Miau : Leichtere Alternative zu Commander.js

Yargs : Anspruchsvollere Argumentanalyse (schwer).

Vorpal.js : Reife / interaktive Befehlszeilenanwendungen mit Argumentanalyse.

Optimist (Knotenoptimist)

Schauen Sie sich die Optimist-Bibliothek an , sie ist viel besser als das manuelle Parsen von Befehlszeilenoptionen.

Aktualisieren

Optimist ist veraltet. Versuchen Yargs , eine aktive Gabel des Optimisten.

Einige gute Antworten hier, aber alles scheint sehr komplex. Dies ist sehr ähnlich dem Zugriff von Bash-Skripten auf Argumentwerte und wird bereits standardmäßig mit node.js bereitgestellt, wie MooGoo hervorhob. (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 zum Definieren Ihrer Optionen, Aktionen und Argumente. Außerdem werden die Hilfeseiten für Sie generiert.

Sofort

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

Co-Prompt

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

Keine Bibliotheken mit Flags, die in ein einfaches 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('=');
            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);

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

Stdio Bibliothek

Der einfachste Weg, Befehlszeilenargumente in NodeJS zu analysieren, ist die Verwendung des stdio- Moduls. Inspiriert vom UNIX- getoptDienstprogramm 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, required: 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

Dann wird das opsObjekt 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 -omstatt schreiben können -o -m.

Darüber hinaus stdiokann automatisch eine Hilfe- / Nutzungsausgabe generiert werden. Wenn Sie anrufen, erhalten ops.printHelp()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 Meldung wird auch angezeigt, wenn keine obligatorische Option angegeben ist (vorangestellt von der Fehlermeldung) oder wenn sie falsch angegeben ist (z. B. wenn Sie ein einzelnes Argument für eine Option angeben und diese 2 benötigt).

Sie können installieren stdio- Modul mit NPM :

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 Ihr Skript:

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

Kommandozeilen-Argumente sind einen Blick wert!

Sie können Optionen mithilfe der Hauptnotationsstandards festlegen ( 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 zunächst eine Liste mit Optionsdefinitionen, in denen die von Ihrer Anwendung akzeptierten Optionen beschrieben werden. Die typeEigenschaft ist eine Setter-Funktion (der angegebene Wert wird hierdurch übergeben), sodass Sie die volle Kontrolle über den empfangenen Wert haben.

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 Verwendung

Neben der oben genannten typischen Verwendung können Sie Befehlszeilenargumente so konfigurieren, dass sie erweiterte Syntaxformulare akzeptieren.

Befehlsbasierte Syntax (Git-Stil) 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 Nutzungsrichtlinien

Ein Verwendungsleitfaden (normalerweise gedruckt, wenn er festgelegt --helpist) kann mithilfe der Befehlszeilennutzung erstellt werden . Sehen Sie sich die folgenden Beispiele an und lesen Sie die DokumentationAnweisungen zum Erstellen finden Sie in .

Ein typisches Beispiel für eine Bedienungsanleitung.

Die Gebrauchsanweisung für Polymer-Cli ist ein gutes Beispiel aus der Praxis .

Weiterführende Literatur

Es gibt noch viel mehr zu lernen. Beispiele und Dokumentation finden Sie im Wiki .

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 Seite github / npm:

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

Die Ausgabe erfolgt hier (sie 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' ]

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 schlägt natürlich fehl, wenn das Argument a enthält =. Dies ist nur für eine sehr einfache Verwendung.

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

Es hilft Ihnen beim Arbeiten mit Konfigurationsdateien, Umgebungsvariablen und Befehlszeilenargumenten.

ohne librairies: using 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 analysieren

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

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

Wenn Sie ein Skript mit den folgenden Elementen ausführen

$ node args.js arg1 arg2

Datei: args.js

console.log(process.argv)

Sie erhalten Array wie

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

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

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 Ihrer Bearbeitung (C: \ Programme \ nodejs \ node.exe ')

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

2 : Dein erstes Argument zum Knoten (arg1)

3 : Dein zweites Argument zum Knoten (arg2)

4 : Dein drittes Argument zum Knoten (arg3)

Ihre eigentlichen Argumente beginnen mit dem 2ndIndex des argvArrays process.argv[2].

Sie können Befehlszeilenargumente mit erreichen system.args. Und ich benutze die folgende Lösung, um Argumente in ein Objekt zu analysieren, damit ich das gewünschte mit Namen erhalten kann.

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 mehr kennen. benutze es wieargs.whatever

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

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

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

Dann tun Sie einfach:

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

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

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

Obwohl die obigen Antworten perfekt sind und jemand bereits Yargs vorgeschlagen hat, ist die Verwendung des Pakets wirklich einfach. Dies ist ein schönes Paket, das das Übergeben 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.

Das Übergeben von Argumenten ist einfach, und das Empfangen von Argumenten ist nur eine Frage des Lesens des process.argv-Array-Knotens, der im Grunde genommen von überall zugänglich ist. Aber Sie möchten sie sicher als Schlüssel / Wert-Paare lesen, daher benötigen Sie ein Skript, um es zu interpretieren.

Joseph Merdrignac hat eine schöne Version mit reduct gepostet, die sich jedoch auf eine key=valueSyntax anstelle von -k valueund stützte --key value. Ich habe es viel hässlicher und länger umgeschrieben, um diesen zweiten Standard zu verwenden, und ich werde es als Antwort veröffentlichen, weil es nicht als Kommentar passen würde. Aber es erledigt den Job.

   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 foxtrotIhnen das folgende Objekt geben

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

Der einfachste Weg, Argumente in Node.js abzurufen, 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 lediglich Argumente an eine Node.js-Anwendung übergeben, wie wir zuvor 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 die ausführbare Datei des Knotens verweist. Das zweite Element ist der Name der ausgeführten JavaScript-Datei. Und das dritte Element ist das erste Argument, das der Benutzer tatsächlich übergeben hat.

'use strict';

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

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

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

TypeScript-Lösung ohne Bibliotheken:

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

Eingang: ts-node index.js -p param --parameter parameter

Ausgabe: { p: 'param ', parameter: 'parameter' }

process.argvIst Ihr Freund, wird das Erfassen von Befehlszeilenargumenten in Node JS nativ unterstützt. Siehe Beispiel unten ::

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

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

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

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

Die meisten Leute haben gute Antworten gegeben. Ich möchte hier auch etwas beitragen. Ich gebe die Antwort mithilfe der lodashBibliothek, 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 obigen 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

Der beste Weg, Befehlszeilenargumente an ein Node.js-Programm zu übergeben, ist die Verwendung einer Befehlszeilenschnittstelle (Command Line Interface, CLI).

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

Wenn Sie eine ohne Abhängigkeiten erstellen möchten, habe ich eine auf meinem Github. Wenn Sie sie überprüfen möchten, ist sie eigentlich recht einfach und benutzerfreundlich. Klicken Sie hier .

Lösung ohne Abhängigkeiten im ES6-Stil:

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