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.

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

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.

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

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.

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.

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"

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.

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

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

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'

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.

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

Dalsza lektura

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

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

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.

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

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

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

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'

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

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.

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

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

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.

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

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.

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

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

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

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

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 .

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