Jak przekazać argumenty wiersza poleceń do programu Node.js?


2413

Mam serwer WWW napisany w Node.js i chciałbym uruchomić z określonego folderu. Nie jestem pewien, jak uzyskać dostęp do argumentów w JavaScript. Korzystam z takiego węzła

$ node server.js folder

oto server.jsmój kod serwera. Pomoc Node.js mówi, że jest to możliwe:

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

Jak mam uzyskać dostęp do tych argumentów w JavaScript? Jakoś nie udało mi się znaleźć tych informacji w Internecie.

Odpowiedzi:


3046

Metoda standardowa (bez biblioteki)

Argumenty są przechowywane w process.argv

Oto dokumentacja węzła dotycząca obsługi argumentów wiersza poleceń:

process.argvto tablica zawierająca argumenty wiersza poleceń. Pierwszym elementem będzie „węzeł”, drugim elementem będzie nazwa pliku JavaScript. Kolejnymi elementami będą wszelkie dodatkowe argumenty wiersza poleceń.

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

Spowoduje to wygenerowanie:

$ 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

7
Co powinienem wpisać w wierszu polecenia, aby uruchomić skrypt node.js z argumentami wiersza polecenia?
Anderson Green,

8
AKTUALIZACJA: Znalazłem odpowiedź na powyższe pytanie. stackoverflow.com/questions/12925802/...
Anderson Green,

2
Minimist to świetny i prosty parser argumentów
Guilherme Nagatomo

4
Możesz również uzyskać dostęp do jednego argumentu, gdy znasz jego pozycję: process.argv[n]gdzie njest indeks zerowy
Luca Steeb

6
drugi element (process.argv [1]) może być plikiem js lub nim nie być. Składnia polecenia węzła to node [options] [ -e script | script.js ] [arguments]lub node debug script.js [arguments]. na przykład: node --harmony script.js balalalub node --no-deprecation --enable-ssl2 script.js balalamożemy użyć process.execArgv z process.argv
cuixiping

678

Aby znormalizować argumenty, jakie otrzymywałaby zwykła funkcja javascript, robię to w skryptach powłoki node.js:

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

Zauważ, że pierwszy argument jest zwykle ścieżką do nodejs, a drugi argument jest lokalizacją wykonywanego skryptu.


19
Notatka, że ​​napisałem tę odpowiedź 4 lata temu, a kod, który używam, nadal działa w 100% dobrze. Nadal jestem na bieżąco z najnowszymi wersjami węzła i ciągle zero problemów: to tylko zwykli ludzie skryptów powłoki. Nie jest częścią dużego globalnego obiektu pełnego bibliotek JS. Nadal popieram dziś moją odpowiedź. Dam kolejną aktualizację za 4 lata.
Mauvis Ledford,

55
var args = process.argv.splice(process.execArgv.length + 2);// ponieważ istnieją wyjątki od użycia polecenia węzła, na przykład: node --harmony script.js balala. patrz process.execArgv
cuixiping

36
@cuixiping ale execArgvto nie w argvtak na 2 wystarcza
Tommi Kyntola

7
Po przejrzeniu historii edycji tej odpowiedzi chciałbym poświęcić chwilę na zrozumienie @MauvisLedford. Nie ma nic bardziej irytującego niż niechciane zmiany w kodzie w imię osobistych preferencji (bez wymiernych korzyści, bootowanie). Komu to się przyda: odrzuć.
Jonathan Dumaine

12
NIEprocess.argv.splice(process.execArgv.length + 2) : dla polecenia node --harmony script.js --version, process.argvjest ['/usr/local/bin/node', 'script.js', '--version']. Flagi NIEnode są uwzględnione w ! process.argv
Константин Ван

360

Aktualna poprawna odpowiedź na to, aby użyć biblioteki minimalistycznej . Kiedyś używaliśmy optymalizatora węzłów, ale od tego czasu jest on przestarzały.

Oto przykład tego, jak z niego korzystać zaczerpnięty z dokumentacji minimalistycznej:

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

32
W rzeczywistości to rozwiązanie jest bardziej pomocne przy opracowywaniu narzędzia wiersza poleceń z większą liczbą flag i argumentów, i powinno być oceniane więcej IMHO.
JK ABC,

2
Imo, jest to prostsza alternatywa dla npmjs.com/package/command-line-args
klodoma

5
@JKABC Nie nazwałbym tego najbardziej poprawną odpowiedzią, ponieważ OP prosi jedynie o dostęp do trywialnych informacji z wiersza poleceń. Ale zgadzam się, że zarówno minimalistyczny, jak i argumenty wiersza poleceń są bardzo przydatne, jeśli planujesz rozszerzyć swój CLI.
Justus Romijn,

2
Zastanawiam się, dlaczego „-n5” nie produkuje „n5: true” - to miałoby dla mnie sens.
Max Waterman

7
@MaxWaterman: ponieważ opcje rozpoczynające się od pojedynczego myślnika mają przypisać tylko jeden znak. Wszystko, co następuje po opcji pojedynczego znaku, jest traktowane jako argument dla tej opcji (nie wymaga spacji). Rozpoczęcie opcji od dwóch myślników (tj. --N5) powinno dać „n5: prawda”. Jest to dość standardowe zachowanie większości narzędzi uniksowych wiersza poleceń (ale nie wszystkie niestety).
Menno Smits

313

Odpowiedź na 2018 r. W oparciu o aktualne trendy na wolności:


Analiza argumentów Vanilla javascript:

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

Zwraca to:

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

Oficjalne dokumenty


Najczęściej używane pakiety NPM do analizy argumentów:

Minimalist : minimalne przetwarzanie argumentów.

Commander.js : Najczęściej stosowany moduł do analizy argumentów.

Meow : Lżejsza alternatywa dla Commander.js

Yargs : Bardziej wyrafinowane parsowanie argumentów (ciężkie).

Vorpal.js : dojrzałe / interaktywne aplikacje wiersza polecenia z analizą argumentów.


76
„$ npm install -g yargs” przyniosło 1,9 MB kodu JavaScript. Kiedy to szaleństwo skończy się, gdy biblioteka parserów argv potrzebuje dwóch megabajtów kodu? Zwiększona powierzchnia ataku, zmarnowana pamięć RAM itp.
joonas.fi 13.10.16

9
Yargs to większe narzędzie, które zdarza się także analizować argumenty wiersza poleceń. Bez szaleństwa, po prostu brak informacji. Jeśli chcesz czegoś lżejszego, użyj surowego JS, Meow lub Minimalist.
dthree

1
„$ npm i yargs” -> 800 KB tutaj, myślę, że właściciele pakietów w końcu nauczyli się ignorować nieistotne pliki. W każdym razie wciąż duży dla głupich projektów, ale mały, gdy potrzebujesz solidności, a przy większych projektach masz już zależności.
Andre Figueiredo

3
Stworzyłem pakiet o nazwie wily-cli , którego celem jest stworzenie mocniejszego, łatwiejszego do dostosowania i łatwiejszego w użyciu narzędzia niż wymienione duże nazwiska. Dla tych, którzy są zainteresowani, to tylko 94,6 KB po instalacji
Jason

1
Koszt importu vscode mówi mi, że yargs (159,2 K) jest teraz lżejszy niż meow (180,2 K). Minimalist wciąż bije je w 3,4K!
Shivam Tripathi

124

Optymista (optymista węzła)

Sprawdź bibliotekę optymistów , jest znacznie lepsza niż ręczne analizowanie opcji wiersza poleceń.

Aktualizacja

Optymista jest przestarzały. Wypróbuj yargs, który jest aktywnym widelcem optymisty.


18
+1 za link. Istnieje dość długa lista parserów opcji wiersza poleceń na github.com/joyent/node/wiki/modules#wiki-parsers-commandline
Thilo

7
Minimist to kolejny następca przestarzałego optymisty. To „parser argumentu optymisty bez wszystkich fantazyjnych dekoracji”. 23 miliony pobrań w ostatnim miesiącu (stan na 12/2015).
aap

96

Kilka świetnych odpowiedzi tutaj, ale wszystko wydaje się bardzo złożone. Jest to bardzo podobne do tego, w jaki sposób skrypty bash uzyskują dostęp do wartości argumentów i jak już zauważył MooGoo, jest już standardowo wyposażony w node.js. (Aby uczynić to zrozumiałym dla kogoś, kto jest nowy w node.js)

Przykład:

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

80

Commander.js

Działa świetnie do definiowania opcji, akcji i argumentów. Generuje również strony pomocy dla Ciebie.

Natychmiast

Działa doskonale do uzyskiwania informacji od użytkownika, jeśli podoba Ci się podejście zwrotne.

Co-Monituj

Działa doskonale do uzyskiwania danych wejściowych od użytkownika, jeśli podoba Ci się podejście generatora.


26
@Evan Carroll, proszę, nie edytuj mojej odpowiedzi, aby promować bibliotekę. Nie używam stackoverflow.com/posts/7483600/revisions, zwłaszcza z powodu brakującej funkcji, której szukasz, takie opinie należy zapisać na komentarze lub wyciągnąć wnioski do autorzy modułu, nie edytują odpowiedzi innych osób.
balupton

Commander.js naprawdę mi pomógł. Inne biblioteki nie działałyby z kompilatorem nexe, ale ta załatwia sprawę. Jeśli chcesz uzyskać argumenty podczas korzystania z nexe, koniecznie przekaż -f do kompilatora nexe.
pierce.jason

60

Brak bibliotek lib z flagami sformatowanymi w prosty obiekt

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

Przykłady

Prosty

Wejście

node test.js -D --name=Hello

wynik

{ D: true, name: 'Hello' }

Prawdziwy świat

Wejście

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

wynik

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

1
Ponieważ niektóre flagi mają długą formę, możesz to uwzględnić. Zamiast tego = longArg[1]możesz napisać. = longArg.length > 1 ? longArg[1] : true;Pozwoliłoby to przekazać ten typ argumentu:node config/build.js --flag1 --flag2
tralston

Lubię to. To wydłużyło linię, więc zerwałem. Dziękuję, że mi o tym powiedziałeś.
Michael Warner

54

Biblioteka Stdio

Najłatwiejszym sposobem analizowania argumentów wiersza poleceń w NodeJS jest użycie modułu stdio . Zainspirowany getoptnarzędziem UNIX jest tak trywialny jak:

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

Jeśli uruchomisz poprzedni kod za pomocą tego polecenia:

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

Następnie opsobiekt będzie wyglądał następująco:

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

Możesz więc używać go tak, jak chcesz. Na przykład:

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

Obsługiwane są również opcje zgrupowane, więc możesz pisać -omzamiast -o -m.

Ponadto stdiomoże automatycznie generować dane wyjściowe dotyczące pomocy / użytkowania. Jeśli zadzwonisz ops.printHelp(), otrzymasz:

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

Poprzedni komunikat jest wyświetlany także wtedy, gdy nie podano obowiązkowej opcji (poprzedzona komunikatem o błędzie) lub jeśli jest niepoprawnie określona (na przykład, jeśli podasz pojedynczy argument dla opcji i potrzebuje 2).

Możesz zainstalować moduł stdio za pomocą NPM :

npm install stdio

3
Jeśli chodzi o warunki SO, warto wspomnieć, że @sgmonda jest jedynym opiekunem modułu;) Jednak ładny mały moduł. Zdecydowanie przydatne.
Qix - MONICA MISTREATED

1
Rzeczywiście przydatne, choć najnowsza aktualizacja była 30 grudnia 2014 r. Może nie być tak dobrze utrzymana, jak niektóre inne pakiety.
nieustraszony_głupiec

niezła lib! tks! chociaż nie ma ostatnich aktualizacji. Ma wystarczająco dobrą funkcjonalność
Pablo Ezequiel,

Minęło trochę czasu, ale właśnie wydałem wersję 2, z pełną obietnicą i obsługą maszynopisu. :-)
sgmonda,

47

Jeśli skrypt nazywa się myScript.js i chcesz przekazać imię i nazwisko „Sean Worthington” jako argumenty takie jak poniżej:

node myScript.js Sean Worthington

Następnie w swoim skrypcie piszesz:

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

28

Argument wiersza poleceń jest wart spojrzenia!

Możesz ustawić opcje za pomocą głównych standardów notacji ( dowiedz się więcej ). Wszystkie te polecenia są równoważne, ustawiając te same wartości:

$ 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

Aby uzyskać dostęp do wartości, najpierw utwórz listę definicji opcji opisującą opcje akceptowane przez aplikację. typeNieruchomość jest funkcją seter (wartość dostarczana jest przepuszczany przez to), co daje pełną kontrolę nad wartością otrzymanej.

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

Następnie przeanalizuj opcje za pomocą komendy CommandLineArgs () :

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

options teraz wygląda następująco:

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

Zaawansowane użycie

Oprócz powyższego typowego użycia można skonfigurować argumenty wiersza polecenia, aby akceptować bardziej zaawansowane formularze składniowe.

Składnia oparta na poleceniach (styl git) w postaci:

$ executable <command> [options]

Na przykład.

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

Składnia polecenia i polecenia podrzędnego (styl dokera) w postaci:

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

Na przykład.

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

Generowanie przewodnika użytkowania

Przewodnik użytkowania (zwykle drukowany, gdy --helpjest ustawiony) można wygenerować za pomocą użycia wiersza polecenia . Zobacz poniższe przykłady i przeczytaj dokumentację aby uzyskać instrukcje dotyczące ich tworzenia.

Typowy przykład instrukcji użytkowania.

stosowanie

Przewodnik użytkowania polimeru-cli jest dobrym przykładem z życia.

stosowanie

Dalsza lektura

Jest jeszcze wiele do nauczenia się, zobacz przykłady i dokumentację na wiki .


@ Lloyd ma to związek z już podniesionym problemem - tutaj . Webstorm przekazuje dodatkowe argumenty.
kboom

@kboom ten problem został rozwiązany przez opcje partiali stopAtFirstUnknown. Zobacz dokumenty .
Lloyd

23

Jest na to aplikacja. Cóż, moduł. Cóż, więcej niż jeden, prawdopodobnie setki.

Yargs jest jednym z zabawnych, jego dokumenty są fajne do czytania.

Oto przykład ze strony github / npm:

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

Wyjście jest tutaj (odczytuje opcje z myślnikami itp., Krótkie i długie, numeryczne itp.).

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

21

Oto moje rozwiązanie 0-dep dla nazwanych argumentów:

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)

Przykład:

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

Uwaga: Oczywiście to się nie powiedzie, gdy argument zawiera =. Jest to tylko bardzo proste użycie.


12

Prawdopodobnie dobrym pomysłem jest zarządzanie konfiguracją w sposób scentralizowany przy użyciu czegoś takiego jak nconf https://github.com/flatiron/nconf

Pomaga w pracy z plikami konfiguracyjnymi, zmiennymi środowiskowymi, argumentami wiersza poleceń.


A oto konfiguracja , mój własny, minimalny, tylko do odczytu interfejs dla nconf.
Joel Purra

12

bez 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

}, {})

dla tego polecenia node index.js count=2 print debug=false msg=hi

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

również,

możemy zmienić

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

przez (znacznie dłużej)

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

automatycznie parsować wartość logiczną i liczbę

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

Twoja dłuższa wersja ma problem z łańcuchami zawierającymi kropki.
berliner

Sprytne rozwiązanie! Co zrobić, jeśli chcę obsługiwać obie opcje counti copcje wiersza poleceń ( cjako alias / skrót count)?
Alex Vang,

To jest piękne! Ale nie używa standardu „jeden myślnik dla jednego klawisza litery i dwa myślniki dla klawisza słowa”. Niestety moja alternatywa jest zbyt długa i brzydka, aby ją tutaj opublikować, więc dodam jako inną odpowiedź.
isacvale,

10

Przekazywanie, analizowanie argumentów jest łatwym procesem. Węzeł udostępnia właściwość process.argv, która jest tablicą ciągów, które są argumentami, które zostały użyte podczas wywołania węzła. Pierwszy wpis w tablicy to plik wykonywalny Node, a drugi to nazwa twojego skryptu.

Jeśli uruchomisz skrypt z poniższymi narzędziami

$ node args.js arg1 arg2

Plik: args.js

console.log(process.argv)

Otrzymasz tablicę jak

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

9
npm install ps-grab

Jeśli chcesz uruchomić coś takiego:

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

-

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

Lub coś takiego:

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

-

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

1
To repo nie jest już dostępne na github.
steadweb

8

proj.js

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

Terminal:

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

Wynik:

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.

Wyjaśnienie:

0 : Katalog node.exe na twoim komputerze (C: \ Program Files \ nodejs \ node.exe ')

1: Katalog pliku projektu. (proj.js)

2 : Twój pierwszy argument do węzła (arg1)

3 : Twój drugi argument do węzła (arg2)

4 : Twój trzeci argument do węzła (arg3)

twoje rzeczywiste argumenty zaczynają się 2ndod indeksu argvtablicy, to znaczy process.argv[2].


7

Możesz dotrzeć do argumentów wiersza poleceń za pomocą system.args. Korzystam z poniższego rozwiązania, aby parsować argumenty w obiekt, dzięki czemu mogę uzyskać nazwę według nazwy.

var system = require('system');

var args = {};
system.args.map(function(x){return x.split("=")})
    .map(function(y){args[y[0]]=y[1]});

teraz nie musisz znać indeksu argumentu. użyj tego jakargs.whatever

Uwaga: powinieneś używać nazwanych argumentów, takich jak file.js x=1 y=2użycie tego rozwiązania.


Nie można go uruchomić, mapwłaściwość jest niezdefiniowana.
caram

6

Możesz przeanalizować wszystkie argumenty i sprawdzić, czy istnieją.

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

Niż po prostu zrób:

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

4

Bez bibliotek

Jeśli chcesz to zrobić w waniliowym JS / ES6, możesz użyć następującego rozwiązania

pracował tylko w 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;
  }, {});

I to polecenie

node index.js host=http://google.com port=8080 production

da następujący wynik

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 Proszę poprawić kod na mapie i zmniejszyć funkcję, jeśli znajdziesz bardziej eleganckie rozwiązanie, dzięki;)


1
Zgadzam się, ale może być krótszy, nie? let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})
Joseph Merdrignac

4

Chociaż powyższe odpowiedzi są idealne, a ktoś już zasugerował yargs, korzystanie z pakietu jest naprawdę łatwe. Jest to ładny pakiet, który sprawia, że ​​przekazywanie argumentów do wiersza poleceń jest naprawdę łatwe.

npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);

Proszę odwiedzić https://yargs.js.org/, aby uzyskać więcej informacji.


Yargs nie wpływa na sposób przekazywania argumentów w wierszu poleceń, pomaga tylko w odczytaniu ich w kodzie.
user3285954,

4

Przekazywanie argumentów jest łatwe, a ich otrzymywanie to tylko kwestia odczytu procesu. Tablicaargv Węzeł udostępnia w zasadzie z każdego miejsca. Ale na pewno chcesz je odczytać jako pary klucz / wartość, więc potrzebujesz fragmentu skryptu, aby go zinterpretować.

Joseph Merdrignac opublikował piękny, używając redukcji, ale opierał się na key=valueskładni zamiast -k valuei --key value. Przepisałem go o wiele bardziej brzydko i dłużej, aby użyć tego drugiego standardu, i opublikuję go jako odpowiedź, ponieważ nie zmieści się jako komentarz. Ale wykonuje zadanie.

   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
   },{})

Za pomocą tego kodu polecenie node script.js alpha beta -charlie delta --echo foxtrotdałoby ci następujący obiekt


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

3

Najprostszym sposobem wyszukiwania argumentów w Node.js jest tablica process.argv. Jest to obiekt globalny, którego można używać bez importowania dodatkowych bibliotek, aby z niego korzystać. Musisz po prostu przekazać argumenty do aplikacji Node.js, tak jak pokazaliśmy wcześniej, a argumenty te można uzyskać w aplikacji za pośrednictwem tablicy process.argv.

Pierwszym elementem tablicy process.argv zawsze będzie ścieżka systemu plików wskazująca plik wykonywalny węzła. Drugi element to nazwa wykonywanego pliku JavaScript. Trzeci element to pierwszy argument przekazany przez użytkownika.

'use strict';

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

Cały ten skrypt wykonuje pętlę przez tablicę process.argv i drukuje indeksy wraz z elementami przechowywanymi w tych indeksach. Jest to bardzo przydatne do debugowania, jeśli kiedykolwiek zastanawiasz się, jakie argumenty otrzymujesz iw jakiej kolejności.

Możesz także używać bibliotek takich jak yargs do pracy z argumentami commnadline.


2

Rozwiązanie TypeScript bez bibliotek:

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

Wejście: ts-node index.js -p param --parameter parameter

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


1

process.argvjest twoim przyjacielem, przechwytywanie argumentów wiersza poleceń jest natywnie obsługiwane w Node JS. Zobacz przykład poniżej:

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

0

jak podano w dokumentach węzła Właściwość process.argv zwraca tablicę zawierającą argumenty wiersza poleceń przekazane podczas uruchamiania procesu Node.js.

Na przykład zakładając następujący skrypt dla procesu-args.js:

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

Uruchamianie procesu Node.js jako:

 $ node process-args.js one two=three four

Wygeneruje wynik:

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four

0

Większość ludzi udzieliła dobrych odpowiedzi. Chciałbym również coś tutaj wnieść. Podaję odpowiedź za pomocą lodashbiblioteki, aby iterować wszystkie argumenty wiersza poleceń, które przekazujemy podczas uruchamiania aplikacji:

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

Aby uruchomić powyżej kodu, uruchom następujące polecenia:

npm install
node index.js xyz abc 123 456

Wynik będzie:

xyz 
abc 
123
456

0

Najlepszym sposobem przekazania argumentów wiersza poleceń do programu Node.js jest użycie interfejsu wiersza poleceń (CLI)

Istnieje fajny moduł npm o nazwie nodejs-cli , którego możesz użyć.

Jeśli chcesz stworzyć taki bez żadnych zależności, mam go na Githubie, jeśli chcesz to sprawdzić, to jest naprawdę prosty i łatwy w użyciu, kliknij tutaj .


0

Rozwiązanie niezależne od stylu ES6:

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());
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.