javascript line - Comment passer des arguments de ligne de commande à un programme nodejs?




argv minimist (19)

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.


Answers

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'

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.


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

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

Yargs est l'un des amusants, ses docs 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 ici (il 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' ]

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.


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

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.


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


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

Si votre script s'appelle myScript.js et que vous voulez 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'

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.


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.


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

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.


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"

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

Passer, analyser les arguments est un processus facile. Le noeud vous fournit la propriété process.argv, qui est un tableau de chaînes, qui sont les arguments utilisés lorsque Node a été appelé. 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 des arguments ci-dessous

$ node args.js arg1 arg2

Fichier: args.js

console.log(process.argv)

Vous obtiendrez un tableau comme

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

This example shows how to use getopt and eval and HEREDOC and shift to handle short and long parameters with and without a required value that follows. Also the switch/case statement is concise and easy to follow.

#!/usr/bin/env bash

# usage function
function usage()
{
   cat << HEREDOC

   Usage: $progname [--num NUM] [--time TIME_STR] [--verbose] [--dry-run]

   optional arguments:
     -h, --help           show this help message and exit
     -n, --num NUM        pass in a number
     -t, --time TIME_STR  pass in a time string
     -v, --verbose        increase the verbosity of the bash script
     --dry-run            do a dry run, don't change any files

HEREDOC
}  

# initialize variables
progname=$(basename $0)
verbose=0
dryrun=0
num_str=
time_str=

# use getopt and store the output into $OPTS
# note the use of -o for the short options, --long for the long name options
# and a : for any option that takes a parameter
OPTS=$(getopt -o "hn:t:v" --long "help,num:,time:,verbose,dry-run" -n "$progname" -- "[email protected]")
if [ $? != 0 ] ; then echo "Error in command line arguments." >&2 ; usage; exit 1 ; fi
eval set -- "$OPTS"

while true; do
  # uncomment the next line to see how shift is working
  # echo "\$1:\"$1\" \$2:\"$2\""
  case "$1" in
    -h | --help ) usage; exit; ;;
    -n | --num ) num_str="$2"; shift 2 ;;
    -t | --time ) time_str="$2"; shift 2 ;;
    --dry-run ) dryrun=1; shift ;;
    -v | --verbose ) verbose=$((verbose + 1)); shift ;;
    -- ) shift; break ;;
    * ) break ;;
  esac
done

if (( $verbose > 0 )); then

   # print out all the parameters we read in
   cat <<-EOM
   num=$num_str
   time=$time_str
   verbose=$verbose
   dryrun=$dryrun
EOM
fi

# The rest of your script below

The most significant lines of the script above are these:

OPTS=$(getopt -o "hn:t:v" --long "help,num:,time:,verbose,dry-run" -n "$progname" -- "[email protected]")
if [ $? != 0 ] ; then echo "Error in command line arguments." >&2 ; exit 1 ; fi
eval set -- "$OPTS"

while true; do
  case "$1" in
    -h | --help ) usage; exit; ;;
    -n | --num ) num_str="$2"; shift 2 ;;
    -t | --time ) time_str="$2"; shift 2 ;;
    --dry-run ) dryrun=1; shift ;;
    -v | --verbose ) verbose=$((verbose + 1)); shift ;;
    -- ) shift; break ;;
    * ) break ;;
  esac
done

Short, to the point, readable, and handles just about everything (IMHO).

Hope that helps someone.





javascript node.js arguments command-line-arguments