javascript - nodejs - yargs




Comment passer des arguments de ligne de commande à un programme nodejs? (15)

J'ai un serveur web écrit dans Node.js et je voudrais lancer avec un dossier spécifique. Je ne suis pas sûr comment accéder aux arguments en JavaScript. Je cours le noeud comme ceci:

$ node server.js folder

ici server.js est mon code serveur. L'aide de Node.js dit 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 réussi à trouver cette information sur le Web.


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

Argument de vanilla javascript:

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

Cela renvoie:

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

Documents officiels

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

Minimist : Pour l'analyse minimale des arguments.

Commander.js : Module le plus utilisé pour l'analyse des arguments.

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

Yargs : Argument d'analyse plus sophistiqué (lourd).

Vorpal.js : Applications de ligne de commande matures / interactives avec analyse d'arguments.


Bibliothèque Stdio

Le moyen le plus simple d'analyser les arguments de la ligne de commande dans NodeJS est d'utiliser le module stdio . Inspiré par l'utilitaire UNIX getopt , 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, mandatory: 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

Alors l'objet ops sera comme suit:

{ 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 supportées, donc vous pouvez écrire -om au lieu de -o -m .

De plus, stdio peut générer automatiquement une sortie d'aide / utilisation. Si vous appelez ops.printHelp() vous obtiendrez:

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 est également montré si une option obligatoire n'est pas donnée (précédée par le message d'erreur) ou si elle est mal spécifiée (par exemple, si vous spécifiez un argument unique pour une option et qu'elle a besoin de 2).

Vous pouvez installer le module stdio utilisant NPM :

npm install stdio

Optimiste (nœud-optimiste)

Jetez un œil à la librairie Optimist , c'est bien mieux que d'analyser les options de la ligne de commande à la main.

Mettre à jour

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


Sans les bibliothèques

Si vous voulez faire cela dans vanille 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 S'il vous plaît corriger le code dans la carte et réduire la fonction si vous trouvez une solution plus élégante, merci;)


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.

Promptly

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

Co-Prompt

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


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.


La bonne réponse à jour pour cela à utiliser la bibliothèque Minimist . Nous avions l'habitude d'utiliser node-optimist mais il a depuis été déprécié.

Voici un exemple de comment l'utiliser directement dans la documentation du 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' }

La plupart des gens ont donné de bonnes réponses. J'aimerais aussi apporter quelque chose ici. Je fournis la réponse en utilisant la bibliothèque lodash pour itérer à travers tous les arguments de la 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 les commandes suivantes:

npm install
node index.js xyz abc 123 456

Le résultat sera:

xyz 
abc 
123
456

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 standard avec node.js comme MooGoo l'a souligné. (Juste pour le rendre compréhensible à quelqu'un qui est nouveau à 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"

Pour normaliser les arguments comme une fonction javascript normale recevrait, je le fais 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 second argument est l'emplacement du script que vous exécutez.


Un simple extrait si vous en avez besoin:

var fs = require('fs'), objMod = {};

process.argv.slice(2).map(function(y, i) {
  y = y.split('=');
  if (y[0] && y[1]) objMod[y[0]] = y[1];
  else console.log('Error in argument number ' + (i+1));
});

Vous pouvez également utiliser le paquet yargs, cela rendra la chose beaucoup plus facile! c'est Yargs :) Yargs


Vous pouvez atteindre les arguments de la ligne de commande en utilisant system.args . Et j'utilise la solution ci-dessous pour analyser les arguments dans un objet, donc je peux 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. utilisez-le comme args.whatever

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


comme indiqué dans les documents de noeud La propriété process.argv renvoie un tableau contenant les arguments de ligne de commande transmis lorsque le processus Node.js a été lancé.

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

npm install ps-grab

Si vous voulez 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'




command-line-arguments