javascript - Hur skickar jag kommandoradsargument till ett Node.js-program och tar emot dem?

Jag har en webbserver skriven i Node.js och jag skulle vilja starta den med en specifik mapp. Jag är inte säker på hur man får åtkomst till argument i JavaScript. Jag kör node på detta sätt:

node server.js folder

här server.js är min serverkod. Node.js hjälp säger att detta är möjligt:

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

Hur skulle jag få åtkomst till de argumenten i JavaScript? På något sätt kunde jag inte hitta denna information på webben.

Svar #1

Standardmetod (utan bibliotek)

Argumenten lagras i process.argv

Här är Node-dokumentationen om hantering av kommandoradsargument:

process.argv är en array som innehåller kommandoradsargumenten. Det första elementet kommer att vara 'node', det andra elementet kommer att vara namnet på JavaScript-filen. De nästa elementen kommer att vara eventuella ytterligare kommandoradsargument.

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

Detta kommer att generera:

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

Svar #2

För att normalisera argumenten som en vanlig JavaScript-funktion skulle få, gör jag så här i mina Node.js-skal-skript:

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

Observera att det första argumentet vanligtvis är sökvägen till nodejs, och det andra argumentet är platsen för skriptet du kör.

Svar #3

Det uppdaterade rätta svaret för detta är att använda minimist-biblioteket. Vi brukade använda node-optimist men det har sedan dess blivit föråldrat.

Här är ett exempel på hur man använder det, taget direkt från minimist-dokumentationen:

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

Svar #4

2018 svar baserat på nuvarande trender i naturen:

Vaniljjavascript argumentparsing:

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

Detta returnerar:

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

Officiella dokument

Mest använda NPM-paket för argumentanalys:

Minimist: För minimal argumentparsning.

Commander.js: Mest använda modulen för argumentanalys.

Meow: Lättare alternativ till Commander.js

Yargs: Mer sofistikerad argumentanalys (tung).

Vorpal.js: Mogna/interaktiva kommandoradsapplikationer med argumentanalys.

Svar #5

Inga bibliotek med flaggor formaterade till ett enkelt objekt

const getArgs = () =>
  process.argv.reduce((args, arg) => {
    // long arg
    if (arg.slice(0, 2) === "--") {
      const longArg = arg.split("=");
      const longArgFlag = longArg[0].slice(2);
      const longArgValue = longArg.length > 1 ? longArg[1] : true;
      args[longArgFlag] = longArgValue;
    }
    // flags
    else if (arg[0] === "-") {
      const flags = arg.slice(1).split("");
      flags.forEach((flag) => {
        args[flag] = true;
      });
    }
    return args;
  }, {});

const args = getArgs();
console.log(args);

Exempel

Enkel

inmatning

node test.js -D --name=Hello

utdata

{ D: true, name: 'Hello' }

Verkliga världen

inmatning

node config/build.js -lHRs --ip=$HOST --port=$PORT --env=dev

utdata

{ 
  l: true,
  H: true,
  R: true,
  s: true,
  ip: '127.0.0.1',
  port: '8080',
  env: 'dev'
}

Svar #6

Optimist (node-optimist)

Kolla in optimistbiblioteket, det är mycket bättre än att analysera kommandoradsalternativ för hand.

Uppdatering

Optimist är föråldrat. Testa yargs som är en aktiv gaffel av optimist.

Svar #7

Flera bra svar här, men allt verkar mycket komplext. Detta är väldigt likt hur bash-skript får åtkomst till argumentvärden och det tillhandahålls redan standardmässigt med node.js som MooGoo påpekade. (Bara för att göra det förståeligt för någon som är ny på node.js)

Exempel :

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"

Svar #8

Commander.js

Fungerar utmärkt för att definiera dina alternativ, åtgärder och argument. Det genererar också hjälpsidorna åt dig.

Omgående

Fungerar utmärkt för att få inmatning från användaren, om du gillar callback-approachen.

Co-Prompt

Fungerar utmärkt för att få inmatning från användaren, om du gillar generatornmetoden.

Svar #9

Stdio-biblioteket

Det enklaste sättet att tolka kommandoradsargument i NodeJS är att använda stdio-modulen. Inspirerad av UNIX-verktyget getopt, är det så enkelt som följer:

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

Om du kör den tidigare koden med detta kommando:

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

Då kommer ops-objektet att se ut som följer:

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

Så att du kan använda det som du vill. Till exempel:

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

Grupperade alternativ stöds också, så du kan skriva -om istället för -o -m.

Dessutom kan stdio automatiskt generera en hjälp-/användningsutdata. Om du anropar ops.printHelp() får du följande:

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

Det föregående meddelandet visas också om ett obligatoriskt alternativ inte anges (föregås av felmeddelandet) eller om det är felaktigt specificerat (till exempel om du anger ett enda argument för ett alternativ och det behöver 2).

Du kan installera stdio-modulen med NPM:

npm install stdio

Svar #10

Om ditt skript heter myScript.js och du vill skicka för- och efternamn, 'Sean Worthington', som argument som nedan:

node myScript.js Sean Worthington

Sedan skriver du i ditt skript:

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

Svar #11

Enkel + ES6 + ingen beroende + stödjer booleska flaggor

const process = require( 'process' );

const argv = key => {
  // Return true if the key exists and a value is undefined
  if ( process.argv.includes( `--${ key }` ) ) return true;

  const value = process.argv.find( element => element.startsWith( `--${ key }=` ) );

  // Return null if the key does not exist and a value is undefined
  if ( !value ) return null;
  
  return value.replace( `--${ key }=` , '' );
}

Utdata:

• Om det körs med node app.js kommer argv('foo') att returnera null
• Om det anropas med node app.js --foo kommer argv('foo') returnera true
• Om den anropas med node app.js --foo= kommer argv('foo') att returnera ''
• Om det anropas med node app.js --foo=bar kommer argv('foo') att returnera 'bar'

Svar #12

command-line-args är värd en titt!

Du kan ställa in alternativ med de huvudsakliga notationsstandarderna (läs mer). Dessa kommandon är alla likvärdiga och ställer in samma värden:

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

För att få tillgång till värdena, skapa först en lista med alternativdefinitioner som beskriver de alternativ som din applikation accepterar. type-egenskapen är en setterfunktion (värdet som tillhandahålls skickas genom denna), vilket ger dig full kontroll över det mottagna värdet.

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

Nästa, analysera alternativen med commandLineArgs():

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

options ser nu ut så här:

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

Avancerad användning

Förutom ovanstående typiska användning kan du konfigurera kommandoradsargument för att acceptera mer avancerade syntaxformer.

Kommandobaserad syntax (git-stil) i formen:

executable <command> [options]

Till exempel.

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

Kommandot och underkommandots syntax (docker-stil) i formen:

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

Till exempel.

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

Generering av användarguide

En användarguide (vanligtvis utskriven när --help är angiven) kan genereras med command-line-usage. Se exemplen nedan och läs dokumentationen för instruktioner om hur man skapar dem.

Ett typiskt exempel på användarguide.

Polymer-cli användarguide är ett bra exempel från verkliga livet.

Vidare läsning

Det finns mycket mer att lära sig, vänligen se wikin för exempel och dokumentation.

Svar #13

Här är min 0-dep-lösning för namngivna argument:

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)

Exempel :

node test.js foo=bar fizz=buzz
bar
buzz

Observera: Naturligtvis kommer detta att misslyckas när argumentet innehåller en =. Detta är endast för mycket enkel användning.

Svar #14

Inbyggd metod

Nodejs-teamet lade till util.parseArgs-funktionen i versionerna 18.3.0 och 16.17.0. Så om du använder dessa eller högre versioner av nodejs kan du analysera kommandoradsargument med denna inbyggda lösning. parseArgs var experimentell fram till v18 och är stabil från v20.

Ett exempel på användning från dokumentationen:

const {parseArgs} = require('node:util');

const args = process.argv;
const options = {
  foo: {
    type: 'boolean',
    short: 'f'
  },
  bar: {
    type: 'string'
  }
};
const {
  values,
  positionals
} = parseArgs({ args, options, allowPositionals: true });

console.log(values);
console.log(positionals);

Exempel på utdata:

node parseargs.js -f --bar b
[Object: null prototype] { foo: true, bar: 'b' }
[
  '/Users/mbelsky/.nvm/versions/node/v18.12.1/bin/node',
  '/Users/mbelsky/parseargs.js'
]

Svar #15

Det finns en app för det. Nä, ett modul. Nä, mer än ett, förmodligen hundratals.

Yargs är en av de roliga, dess dokumentation är kul att läsa.

Här är ett exempel från GitHub/npm-sidan:

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

Utdata finns här (det läser alternativ med bindestreck osv, kort och långt, numeriskt osv).

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

Svar #16

proj.js

for(var i=0;i<process.argv.length;i++){
  console.log(process.argv[i]);
}

Terminal:

nodemon app.js "arg1" "arg2" "arg3"

Resultat:

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.

Förklaring:

0. Katalogen för node.exe på din dator (C:\Program Files\nodejs\node.exe)
1. Katalogen för din projektfil (proj.js)
2. Ditt första argument till noden (arg1)
3. Ditt andra argument till noden (arg2)
4. Ditt tredje argument till noden (arg3)

dina faktiska argument börjar från andra indexet av argv-arrayen, det vill säga process.argv[2].

Svar #17

utan bibliotek: använda 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 detta kommando node index.js count=2 print debug=false msg=hi

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

också,

vi kan förändra

    let [k, v = true] = arg.split('=')
    acc[k] = v

med (mycket längre)

    let [k, v] = arg.split('=')
    acc[k] = v === undefined ? true : /true|false/.test(v) ? v === 'true' : /[\d|\.]+/.test(v) ? Number(v) : v

att automatiskt tolka Boolean & Number

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

Svar #18

Analyserar argument baserat på standardinmatning ( --key=value )

const argv = (() => {
    const arguments = {};
    process.argv.slice(2).map( (element) => {
        const matches = element.match( '--([a-zA-Z0-9]+)=(.*)');
        if ( matches ){
            arguments[matches[1]] = matches[2]
                .replace(/^['"]/, '').replace(/['"]$/, '');
        }
    });
    return arguments;
})();

Kommandosexempel

node app.js --name=stackoverflow --id=10 another-argument --text="Hello World"

Resultatet av argv: console.log(argv)

{
    name: "stackoverflow",
    id: "10",
    text: "Hello World"
}

Svar #19

I node-koden, kräva det inbyggda processbiblioteket.

const {argv} = require('process')

Kör programmet med deras argument.

node process-args.js one two=three four

argv är den array som följer:

argv[0] = /usr/bin/node
argv[1] = /home/user/process-args.js
argv[2] = one
argv[3] = two=three
argv[4] = four

Svar #20

Att skicka och parsar argument är en enkel process. Node ger dig egenskapen process.argv, vilket är en array av strängar, som är de argument som användes när Node startades. Den första posten i arrayen är Node-exekverbara filen, och den andra posten är namnet på ditt skript.

Om du kör skriptet med nedanstående argument

node args.js arg1 arg2

Fil : args.js

console.log(process.argv)

Du kommer att få en array som

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

Svar #21

npm install ps-grab

Om du vill köra något liknande detta:

node greeting.js --user Abdennour --website http://abdennoor.com 

--

var grab=require('ps-grab');
grab('--username') // return 'Abdennour'
grab('--action') // return 'http://abdennoor.com'

Eller något liknande:

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

--

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