Comment passer des arguments de ligne de commande à un programme Node.js?


2417

J'ai un serveur Web écrit en Node.js et je voudrais lancer avec un dossier spécifique. Je ne sais pas comment accéder aux arguments en JavaScript. J'exécute un nœud comme ceci:

$ node server.js folder

voici server.jsmon code serveur. L'aide de Node.js indique que c'est possible:

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

Comment accéder à ces arguments en JavaScript? D'une manière ou d'une autre, je n'ai pas pu trouver ces informations sur le Web.

Réponses:


3048

Méthode standard (pas de bibliothèque)

Les arguments sont stockés dans process.argv

Voici les documents du nœud sur la gestion des arguments de ligne de commande:

process.argvest un tableau contenant les arguments de la ligne de commande. Le premier élément sera 'node', le second élément sera le nom du fichier JavaScript. Les éléments suivants seront tous les arguments de ligne de commande supplémentaires.

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

Cela générera:

$ 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
Que dois-je saisir dans l'invite de commande pour exécuter un script node.js avec des arguments de ligne de commande?
Anderson Green

8
MISE À JOUR: J'ai trouvé la réponse à la question ci-dessus. stackoverflow.com/questions/12925802/…
Anderson Green

2
Minimist est un analyseur d'arguments simple et génial
Guilherme Nagatomo

4
Vous pouvez également accéder à un seul argument lorsque vous connaissez sa position: process.argv[n]nest l'indice de base zéro
Luca Steeb

6
le 2ème élément (process.argv [1]) peut être ou ne pas être un fichier js. la syntaxe de commande du nœud est node [options] [ -e script | script.js ] [arguments]ou node debug script.js [arguments]. par exemple: node --harmony script.js balalaou node --no-deprecation --enable-ssl2 script.js balala, nous pouvons utiliser process.execArgv avec process.argv
cuixiping

679

Pour normaliser les arguments comme une fonction javascript régulière recevrait, je fais cela dans mes scripts shell node.js:

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

Notez que le premier argument est généralement le chemin d'accès à nodejs, et le deuxième argument est l'emplacement du script que vous exécutez.


19
Juste une note que j'ai écrit cette réponse il y a 4 ans et que le code que j'utilise fonctionne toujours à 100% aujourd'hui. Toujours à jour avec les dernières versions de node et toujours aucun problème: ce n'est qu'un simple script script shell. Ne fait pas partie d'un grand objet global plein de bibliothèques JS. Je suis toujours derrière ma réponse aujourd'hui. Je donnerai une autre mise à jour dans 4 ans de plus.
Mauvis Ledford

36
@cuixiping mais le execArgvsont pas en argvsorte que le 2 est suffisant
Tommi Kyntola

7
Après avoir regardé l'historique des modifications de cette réponse, je voudrais prendre un moment pour sympathiser avec @MauvisLedford. Il n'y a rien de plus ennuyeux que des modifications non sollicitées de votre code au nom de vos préférences personnelles (sans avantages quantifiables, pour démarrer). À qui cela fait ça: lancez-vous.
Jonathan Dumaine

7
Hé @MauvisLedford, cela fait quatre ans de plus. J'adorerais une mise à jour!
andrew lorien

13
NE PASprocess.argv.splice(process.execArgv.length + 2) : pour une commande node --harmony script.js --version, le process.argvest ['/usr/local/bin/node', 'script.js', '--version']. Les drapeaux nenode sont PAS inclus dans process.argv!
Константин Ван

360

La bonne réponse à jour pour cela est d'utiliser la bibliothèque minimist . Auparavant, nous utilisions node-optimist mais il est depuis déconseillé.

Voici un exemple d'utilisation, tiré directement de la documentation minimiste:

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
En fait, cette solution est plus utile pour développer un outil de ligne de commande avec plus d'indicateurs et d'arguments, et devrait être plus appréciée à mon humble avis.
JK ABC

2
Imo, c'est une alternative plus simple à npmjs.com/package/command-line-args
klodoma

5
@JKABC Je n'appellerais pas cela la réponse la plus correcte, car l'OP demande simplement d'accéder à des informations triviales en ligne de commande. Mais je suis d'accord que les arguments minimist et de ligne de commande sont très utiles si vous prévoyez d'étendre votre CLI.
Justus Romijn

2
Je me demande pourquoi le «-n5» ne produit pas «n5: vrai» - cela aurait du sens pour moi.
Max Waterman

8
@MaxWaterman: parce que les options qui commencent par un seul tiret ne sont supposées concerner qu'un seul caractère. Tout ce qui suit une seule option char est considéré comme un argument pour l'option (aucun espace requis). Le démarrage de l'option avec deux tirets (c'est-à-dire --n5) devrait produire 'n5: true'. C'est un comportement assez standard pour la plupart des outils de ligne de commande Unix (mais pas tous malheureusement).
Menno Smits

313

Réponse 2018 basée sur les tendances actuelles dans la nature:


Analyse d'argument javascript vanilla:

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

Cela renvoie:

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

Documents officiels


Packages NPM les plus utilisés pour l'analyse des arguments:

Minimist : pour une analyse minimale des arguments.

Commander.js : module le plus adopté pour l'analyse des arguments.

Meow : Alternative plus légère à Commander.js

Yargs : analyse d'arguments plus sophistiquée (lourde).

Vorpal.js : applications de ligne de commande matures / interactives avec analyse des arguments.


77
"$ npm install -g yargs" a généré 1,9 Mo de code JavaScript. Quand cette folie va-t-elle se terminer lorsqu'une bibliothèque d'analyseur argv a besoin de deux mégaoctets de code? Surface d'attaque augmentée, RAM gaspillée etc ...
joonas.fi

9
Yargs est un outil plus grand qui permet également d'analyser les arguments de ligne de commande. Pas de folie, juste un manque d'informations. Si vous voulez quelque chose de plus léger, utilisez le JS brut, Meow ou Minimist.
dthree

1
"$ npm i yargs" -> 800 Ko ici, je suppose que les propriétaires de paquets ont finalement appris à ignorer les fichiers non pertinents. Quoi qu'il en soit, toujours gros pour les projets idiots, mais petit quand vous avez besoin de robustesse et sur des projets plus grands, vous avez déjà des dépendances ..
Andre Figueiredo

3
J'ai créé un package, appelé wily-cli , dans le but de rendre un outil plus puissant, plus personnalisable et plus facile à utiliser que les grands noms répertoriés. Pour ceux d'entre vous qui sont intéressés, il n'y a que 94,6 Ko à l'installation
Jason

1
vscode import-cost me dit que yargs (159.2K) est maintenant plus léger que meow (180.2K). Minimist les bat toujours à 3,4K!
Shivam Tripathi

124

Optimiste (node-optimist)

Consultez la bibliothèque optimiste , c'est beaucoup mieux que d'analyser les options de ligne de commande à la main.

Mise à jour

Optimist est obsolète. Essayez yargs qui est une fourchette active d'optimiste.


18
+1 pour le lien. Il y a une assez longue liste d'analyseurs d'options de ligne de commande sur github.com/joyent/node/wiki/modules#wiki-parsers-commandline
Thilo

7
Minimist est un autre successeur de l'optimiste désormais obsolète. C'est "les tripes de l'analyseur de l'argument optimiste sans toute la décoration fantaisiste." 23 millions de téléchargements au cours du dernier mois (au 12/2015).
2015

96

Plusieurs bonnes réponses ici, mais tout cela semble très complexe. Ceci est très similaire à la façon dont les scripts bash accèdent aux valeurs des arguments et il est déjà fourni en standard avec node.js comme l'a souligné MooGoo. (Juste pour le rendre compréhensible pour quelqu'un qui est nouveau sur node.js)

Exemple:

$ 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

Fonctionne très bien pour définir vos options, actions et arguments. Il génère également les pages d'aide pour vous.

Rapidement

Fonctionne très bien pour obtenir des commentaires de l'utilisateur, si vous aimez l'approche de rappel.

Co-invite

Fonctionne très bien pour obtenir des commentaires de l'utilisateur, si vous aimez l'approche du générateur.


26
Carroll @ Evan s'il vous plaît ne pas modifier ma réponse pour promouvoir une bibliothèque , je ne l' utilise pas stackoverflow.com/posts/7483600/revisions surtout à cause d'une fonctionnalité manquante que vous êtes après, ces opinions doivent être enregistrées pour des commentaires ou des demandes de traction à les auteurs du module, pas les modifications apportées aux réponses des autres.
balupton

Commander.js m'a vraiment aidé. D'autres bibliothèques ne fonctionneraient pas avec le compilateur nexe mais celui-ci fait l'affaire. Si vous voulez obtenir des arguments lors de l'utilisation de nexe, assurez-vous de passer -f au compilateur nexe.
pierce.jason

60

Aucune bibliothèque avec des drapeaux formatés en un objet simple

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

Exemples

Facile

contribution

node test.js -D --name=Hello

production

{ D: true, name: 'Hello' }

Monde réel

contribution

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

production

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

1
Étant donné que certains indicateurs ont une forme longue, vous pouvez en tenir compte. Au lieu de = longArg[1]vous pourriez écrire = longArg.length > 1 ? longArg[1] : true;Cela vous permettrait de passer ce type d'argument:node config/build.js --flag1 --flag2
tralston

Je l'aime. Cela a allongé la ligne un peu, alors je l'ai rompue. Merci de m'en avoir parlé.
Michael Warner

54

Bibliothèque Stdio

La façon la plus simple d'analyser les arguments de ligne de commande dans NodeJS est d'utiliser le module stdio . Inspiré par l' getoptutilitaire UNIX , il est aussi trivial que suit:

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

Si vous exécutez le code précédent avec cette commande:

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

L' opsobjet sera alors le suivant:

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

Vous pouvez donc l'utiliser comme vous le souhaitez. Par exemple:

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

Les options groupées sont également prises en charge, vous pouvez donc écrire à la -omplace de -o -m.

En outre, stdiopeut générer automatiquement une sortie d'aide / utilisation. Si vous appelez, ops.printHelp()vous obtiendrez ce qui suit:

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

Le message précédent s'affiche également si aucune option obligatoire n'est indiquée (précédée du message d'erreur) ou si elle est mal spécifiée (par exemple, si vous spécifiez un seul argument pour une option et qu'il en faut 2).

Vous pouvez installer le module stdio à l' aide de NPM :

npm install stdio

3
Selon les TOS de SO, il convient de mentionner @sgmonda est le seul mainteneur du module;) Joli petit module, cependant. Certainement utile.
Qix - MONICA A ÉTÉ BRUÉE le

1
En effet utile, bien que la mise à jour la plus récente ait été le 30 décembre 2014. Peut ne pas être aussi bien maintenue que certains autres packages.
fearless_fool

belle lib! tks! bien que ce soit sans mises à jour récentes .. Il a assez de bonnes fonctionnalités
Pablo Ezequiel

Cela fait un moment mais je viens de publier la version 2, avec une promesse complète et un support dactylographié. :-)
sgmonda

47

Si votre script s'appelle myScript.js et que vous souhaitez passer le prénom et le nom, 'Sean Worthington', comme arguments comme ci-dessous:

node myScript.js Sean Worthington

Ensuite, dans votre script, vous écrivez:

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

28

la ligne de commande-args vaut le détour!

Vous pouvez définir des options en utilisant les principales normes de notation (en savoir plus ). Ces commandes sont toutes équivalentes, définissant les mêmes valeurs:

$ 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

Pour accéder aux valeurs, créez d'abord une liste de définitions d'options décrivant les options acceptées par votre application. La typepropriété est une fonction de définition (la valeur fournie est transmise par ce biais), vous donnant un contrôle total sur la valeur reçue.

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

Ensuite, analysez les options à l'aide de commandLineArgs () :

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

options ressemble maintenant à ceci:

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

Utilisation avancée

Outre l'utilisation typique ci-dessus, vous pouvez configurer des arguments de ligne de commande pour accepter des formes de syntaxe plus avancées.

Syntaxe basée sur les commandes (style git) sous la forme:

$ executable <command> [options]

Par exemple.

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

Syntaxe des commandes et sous-commandes (style docker) sous la forme:

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

Par exemple.

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

Génération de guide d'utilisation

Un guide d'utilisation (généralement imprimé lorsqu'il --helpest défini) peut être généré à l'aide de l'utilisation de la ligne de commande . Consultez les exemples ci-dessous et lisez la documentation pour savoir comment les créer.

Un exemple de guide d'utilisation typique.

usage

Le guide d'utilisation de polymère-cli est un bon exemple réel.

usage

Lectures complémentaires

Il y a beaucoup plus à apprendre, veuillez consulter le wiki pour des exemples et de la documentation.


@Lloyd, cela est lié à un problème déjà soulevé - ici . Webstorm transmet quelques arguments supplémentaires.
kboom

@kboom, ce problème a été résolu par les options partialet stopAtFirstUnknown. Voir les documents .
Lloyd

23

Il y a une application pour ça. Eh bien, module. Eh bien, plus d'un, probablement des centaines.

Yargs est l'un des plus amusants, ses documents sont cool à lire.

Voici un exemple de la page github / npm:

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

La sortie est là (elle lit les options avec des tirets, etc., court et long, numérique, etc.).

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

Voici ma solution 0-dep pour les arguments nommés:

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)

Exemple:

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

Remarque: Naturellement, cela échouera lorsque l'argument contient un =. Ce n'est que pour une utilisation très simple.


12

C'est probablement une bonne idée de gérer votre configuration de manière centralisée en utilisant quelque chose comme nconf https://github.com/flatiron/nconf

Il vous aide à travailler avec des fichiers de configuration, des variables d'environnement, des arguments de ligne de commande.


Et voici la configuration , ma propre interface minimale en lecture seule pour nconf.
Joel Purra

12

sans librairies: utilisation de Array.prototype.reduce ()

const args = process.argv.slice(2).reduce((acc, arg) => {

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

}, {})

pour cette commande node index.js count=2 print debug=false msg=hi

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

aussi,

nous pouvons changer

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

par (beaucoup plus longtemps)

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

pour analyser automatiquement Boolean & Number

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

Votre version longue a un problème avec les chaînes qui contiennent des points.
berliner

Solution intelligente! Que faire si je veux soutenir à la fois countet les coptions de ligne de commande ( ccomme un alias / shorcut pour count)?
Alex Vang

C'est beau! Mais il n'utilise pas la norme "un tiret pour une clé de lettre et deux tirets pour la clé de mot". Malheureusement, mon alternative est trop longue et moche pour être publiée ici, je vais donc ajouter une réponse différente.
isacvale

10

Passer, analyser des arguments est un processus facile. Node vous fournit la propriété process.argv, qui est un tableau de chaînes, qui sont les arguments qui ont été utilisés lors de l'appel de Node. La première entrée du tableau est l'exécutable Node et la deuxième entrée est le nom de votre script.

Si vous exécutez un script avec les atguments ci-dessous

$ node args.js arg1 arg2

Fichier: args.js

console.log(process.argv)

Vous obtiendrez un tableau comme

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

9
npm install ps-grab

Si vous souhaitez exécuter quelque chose comme ceci:

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

-

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

Ou quelque chose comme:

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

-

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

1
Ce dépôt n'est plus disponible sur 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"

Résultat:

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.

Explication:

0 : Le répertoire de node.exe dans votre usinage (C: \ Program Files \ nodejs \ node.exe ')

1: Le répertoire de votre fichier projet. (proj.js)

2 : Votre premier argument au nœud (arg1)

3 : Votre deuxième argument au nœud (arg2)

4 : Votre troisième argument au nœud (arg3)

vos arguments réels commencent l' 2ndindex de forme du argvtableau, c'est-à-dire process.argv[2].


7

Vous pouvez accéder aux arguments de ligne de commande à l'aide de system.args. Et j'utilise la solution ci-dessous pour analyser les arguments dans un objet, afin que je puisse obtenir celui que je veux par son nom.

var system = require('system');

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

maintenant, vous n'avez pas besoin de connaître l'index de l'argument. l'utiliser commeargs.whatever

Remarque: vous devez utiliser des arguments nommés comme file.js x=1 y=2pour utiliser cette solution.


Impossible de le faire fonctionner, la mappropriété n'est pas définie.
caram

6

Vous pouvez analyser tous les arguments et vérifier s'ils existent.

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

Que juste faire:

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

4

Sans bibliothèques

Si vous voulez le faire dans vanilla JS / ES6, vous pouvez utiliser la solution suivante

travaillé uniquement dans 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;
  }, {});

Et cette commande

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

produira le résultat suivant

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 Veuillez corriger le code dans la carte et réduire la fonction si vous trouvez une solution plus élégante, merci;)


1
je suis d'accord, mais ça pourrait être plus court non? let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})
Joseph Merdrignac

4

Bien que les réponses ci-dessus soient parfaites et que quelqu'un ait déjà suggéré des yargs, l'utilisation du package est vraiment facile. C'est un joli package qui facilite la transmission d'arguments à la ligne de commande.

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

Veuillez visiter https://yargs.js.org/ pour plus d'informations.


Yargs n'affecte pas la façon dont les arguments sont passés sur la ligne de commande, il aide uniquement à les lire dans le code.
user3285954

4

Passer des arguments est facile, et les recevoir est simplement une question de lecture du tableau process.argv Node rend accessible de partout, fondamentalement. Mais vous êtes sûr de vouloir les lire sous forme de paires clé / valeur, vous aurez donc besoin d'un morceau à script pour l'interpréter.

Joseph Merdrignac en a posté un beau en utilisant réduire, mais il s'est appuyé sur une key=valuesyntaxe au lieu de -k valueet --key value. Je l'ai réécrit beaucoup plus laid et plus long pour utiliser ce deuxième standard, et je le posterai comme réponse car il ne rentrerait pas dans un commentaire. Mais cela fait le travail.

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

Avec ce code, une commande node script.js alpha beta -charlie delta --echo foxtrotvous donnerait l'objet suivant


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

3

La manière la plus simple de récupérer des arguments dans Node.js est via le tableau process.argv. Il s'agit d'un objet global que vous pouvez utiliser sans importer de bibliothèques supplémentaires pour l'utiliser. Il vous suffit de passer des arguments à une application Node.js, comme nous l'avons montré précédemment, et ces arguments sont accessibles dans l'application via le tableau process.argv.

Le premier élément du tableau process.argv sera toujours un chemin de système de fichiers pointant vers l'exécutable du nœud. Le deuxième élément est le nom du fichier JavaScript en cours d'exécution. Et le troisième élément est le premier argument réellement passé par l'utilisateur.

'use strict';

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

Tout ce que ce script fait est de parcourir le tableau process.argv et affiche les index, ainsi que les éléments stockés dans ces index. Il est très utile pour le débogage si vous vous demandez quels arguments vous recevez et dans quel ordre.

Vous pouvez également utiliser des bibliothèques comme yargs pour travailler avec des arguments commnadline.


2

Solution TypeScript sans bibliothèque:

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

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

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


1

process.argvest votre ami, la capture des arguments de ligne de commande est prise en charge de manière native dans Node JS. Voir l'exemple ci-dessous ::

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

0

comme indiqué dans les documents du nœud. La propriété process.argv renvoie un tableau contenant les arguments de ligne de commande transmis lors du lancement du processus Node.js.

Par exemple, en supposant le script suivant pour process-args.js:

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

Lancement du processus Node.js en tant que:

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

Générerait la sortie:

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

0

La plupart des gens ont donné de bonnes réponses. Je voudrais également contribuer quelque chose ici. Je fournis la réponse en utilisant la lodashbibliothèque pour parcourir tous les arguments de ligne de commande que nous passons lors du démarrage de l'application:

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

Pour exécuter le code ci-dessus, exécutez simplement les commandes suivantes:

npm install
node index.js xyz abc 123 456

Le résultat sera:

xyz 
abc 
123
456

0

La meilleure façon de passer des arguments de ligne de commande à un programme Node.js est d'utiliser une interface de ligne de commande (CLI)

Il existe un module astucieux npm appelé nodejs-cli que vous pouvez utiliser.

Si vous voulez en créer un sans dépendances, j'en ai un sur mon Github si vous voulez le vérifier, c'est en fait assez simple et facile à utiliser, cliquez ici .


0

Solution sans dépendances de style 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());
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.