Vraag Hoe geef ik opdrachtregelargumenten door aan een Node.js-programma?


Ik heb een webserver geschreven Node.js en ik zou willen starten met een specifieke map. Ik weet niet zeker hoe ik toegang krijg tot argumenten in JavaScript. Ik loop een knoop als volgt:

$ node server.js folder

hier server.js is mijn servercode. Node.js help zegt dat dit mogelijk is:

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

Hoe krijg ik toegang tot die argumenten in JavaScript? Op de een of andere manier was ik niet in staat om deze informatie op het web te vinden.


1764
2017-12-04 01:56


oorsprong


antwoorden:


Standaard methode (geen bibliotheek)

De argumenten worden opgeslagen in process.argv

Hier zijn de node docs over afhandeling van opdrachtregel args:

process.argv is een array met de opdrachtregelargumenten. Het eerste element zal 'node' zijn, het tweede element is de naam van het JavaScript-bestand. De volgende elementen zijn eventuele extra opdrachtregelargumenten.

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

Dit zal genereren:

$ 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

2344
2017-12-04 02:05



Om de argumenten te normaliseren zoals een normale javascript-functie zou ontvangen, doe ik dit in mijn node.js shellscripts:

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

Merk op dat de eerste arg gewoonlijk het pad naar nodejs is, en de tweede arg is de locatie van het script dat je aan het uitvoeren bent.


472
2018-04-23 23:13



De up-to-date rechts antwoord hierop om het te gebruiken minimist bibliotheek. We gebruikten het knooppunt-optimist maar het is inmiddels gedeprecieerd.

Hier is een voorbeeld van hoe het rechtstreeks uit de minimist-documentatie kan worden gebruikt:

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

234
2017-07-08 17:26



2018 antwoord op basis van de huidige trends in het wild:


Vanilla javascript argument parsing:

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

Dit levert op:

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

Officiële documenten


Meest gebruikte NPM-pakketten voor argumentargeting:

Minimist: Voor minimale argument-parsing.

Commander.js: Meest aangenomen module voor argument-parsing.

mauw: Lichter alternatief voor Commander.js

Yargs: Geavanceerd parcours parseren (zwaar).

Vorpal.js: Volwassen / interactieve opdrachtregeltoepassingen met argumentargeting.


203
2018-01-14 05:26



Optimist (knooppunt-optimist)

Uitchecken optimist bibliotheek, het is veel beter dan met de hand opdrachten uit de commandoregel te ontleden.

Bijwerken

Optimist is verouderd. Proberen yargs wat een actieve vork van optimist is.


107
2017-07-04 04:02



Verschillende geweldige antwoorden hier, maar het lijkt allemaal erg ingewikkeld. Dit lijkt erg op hoe bash-scripts toegang krijgen tot argumentwaarden en het is al standaard geleverd bij node.js zoals MooGoo heeft aangegeven. (Gewoon om het begrijpelijk te maken voor iemand die onbekend is met node.js)

Voorbeeld:

$ 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"

68
2017-12-12 05:19



Commander.js

Werkt prima voor het definiëren van uw opties, acties en argumenten. Het genereert ook de helppagina's voor u.

onmiddellijk

Werkt prima voor invoer van de gebruiker, als je de callback-benadering leuk vindt.

Co-Prompt

Werkt prima om invoer van de gebruiker te krijgen, als je van de generatorbenadering houdt.


65
2017-09-20 10:20



Stdio-bibliotheek

De eenvoudigste manier om opdrachtregelargumenten in NodeJS te ontleden is met behulp van de stdio module. Geïnspireerd door UNIX getopt nut, het is zo triviaal als volgt:

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

Als u de vorige code uitvoert met deze opdracht:

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

Dan ops object zal als volgt zijn:

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

Dus je kunt het gebruiken zoals je wilt. Bijvoorbeeld:

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

Gegroepeerde opties worden ook ondersteund, dus je kunt schrijven -om in plaats van -o -m.

Voorts stdio kan automatisch een Help / Gebruik-uitvoer genereren. Als je belt ops.printHelp() je krijgt het volgende:

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

Het vorige bericht wordt ook weergegeven als een verplichte optie niet is gegeven (voorafgegaan door het foutbericht) of als het verkeerd is gespecificeerd (bijvoorbeeld als u één arg opgeeft voor een optie en deze 2 nodig heeft).

U kunt installeren stdio module gebruiken NPM:

npm install stdio

35
2017-08-13 10:30



Als uw script myScript.js wordt genoemd en u wilt de voor- en achternaam, 'Sean Worthington', als argumenten zoals hieronder doorgeven:

node myScript.js Sean Worthington

Dan schrijf je in je script:

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

28
2018-06-17 00:04



command-line-args is de moeite van het bekijken waard!

U kunt opties instellen met behulp van de belangrijkste notatie standaarden (kom meer te weten). Deze opdrachten zijn allemaal gelijk, waarbij dezelfde waarden worden ingesteld:

$ 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

Als u toegang wilt tot de waarden, maakt u eerst een lijst met optiedefinities beschrijving van de opties die uw applicatie accepteert. De type eigenschap is een setterfunctie (de geleverde waarde wordt hier doorheen geleid), waardoor u volledige controle hebt over de ontvangen waarde.

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

Parseer vervolgens de opties met commandLineArgs ():

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

options ziet er nu zo uit:

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

Geavanceerd gebruik

Naast het bovenstaande typische gebruik, kunt u command-line-args configureren om meer geavanceerde syntaxisformulieren te accepteren.

Op opdrachten gebaseerde syntaxis (git-stijl) in de vorm:

$ executable <command> [options]

Bijvoorbeeld.

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

Syntaxis van opdracht en subopdracht (docker-stijl) in de vorm:

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

Bijvoorbeeld.

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

Gebruikshandleiding genereren

Een gebruiksgids (meestal afgedrukt wanneer --help is ingesteld) kan worden gegenereerd met behulp van command-line-gebruik. Zie de voorbeelden hieronder en lees de documentatie voor instructies hoe ze te maken.

Een typisch voorbeeld van een gebruiksgids.

usage

De polymeer-cli gebruiksgids is een goed, realistisch voorbeeld.

usage

Verder lezen

Er is nog veel meer te leren, zie alstublieft de wiki voor voorbeelden en documentatie.


19
2017-11-15 16:00



Daar is een app voor. Nou, module. Nou ja, meer dan een, waarschijnlijk honderden.

Yargs is een van de leukste, de documenten zijn cool om te lezen.

Hier is een voorbeeld van de github / npm-pagina:

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

Uitgang is hier (het leest opties met streepjes, enz., Kort en lang, numeriek enz.).

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

16
2018-03-14 00:45