pour normaliser les arguments comme une fonction javascript régulière recevrait, je le fais dans mon noeud.scripts shell js:

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

notez que le premier arg est habituellement le chemin vers nodejs, et le second arg est l'emplacement du script que vous exécutez.

L'up-to-date droit réponse à ce qu'elle utilise le minimist de la bibliothèque. Nous utilisions node-optimist mais il a été déprécié depuis.

voici un exemple d'utilisation tiré directement de la documentation minimist:

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

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

Vanille javascript argument de l'analyse:

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

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

Minimist : pour minimum analyse des arguments.

commandant.js : la Plupart adopté module pour l'argument de l'analyse.

Meow : alternative plus légère au commandant de bord.js

Yargs : plus sophistiqué parsing argument (lourd).

Vorpale.js : Mature / ligne de commande interactive des applications avec l'argument de l'analyse.

Optimiste (nœud-optimist)

Check out optimist library , il est beaucoup mieux que l'analyse des options en ligne de commande à la main.

mise à Jour

Optimist est déprécié. Essayez yargs qui est une fourchette active d'optimiste.

plusieurs grandes réponses ici, mais tout semble très complexe. C'est très similaire à la façon dont les scripts bash accèdent aux valeurs des arguments et c'est déjà fourni en standard avec node.JS comme MooGoo l'a fait remarquer. (Juste pour que ce soit compréhensible pour quelqu'un qui est nouveau au noeud.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"

Commandant de bord.js

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

à bref délai

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 la contribution de l'utilisateur, si vous comme l'approche du générateur.

Stdio Library

la façon la plus facile de traiter les arguments en ligne de commande dans NodeJS est d'utiliser le module stdio . Inspiré par UNIX getopt utilité, 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

puis ops l'objet sera le suivant:

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

pour que vous puissiez l'utiliser comme bon vous semble. Par exemple:

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

sont également supportées, vous pouvez donc écrire -om au lieu de -o -m .

de plus, stdio peut générer automatiquement une sortie 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 une option obligatoire n'est pas indiquée (précédée du message d'erreur) ou si elle est mal précisée (par exemple, si vous spécifiez un seul arg pour une option et il a besoin de 2).

vous pouvez installer stdio module en utilisant NPM :

npm install stdio

si votre script s'appelle myScript.js et que vous souhaitez passer le premier et le dernier nom, "Sean Worthington", comme arguments comme ci-dessous:

node myScript.js Sean Worthington

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

"1519120920 de ligne de commande"-args vaut le coup d'oeil!

vous pouvez définir des options en utilisant les principales normes de notation ( pour 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 que votre application accepte. Le type la propriété est une fonction setter (la valeur fournie est passée par là), vous donnant le 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 en utilisant commandLineArgs () :

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

options ressemble maintenant à ceci:

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

usage avancé

à côté de l'utilisation typique ci-dessus, vous pouvez configurer la ligne de commande-args pour en accepter plus formes syntaxiques avancées.

"1519360920 de la Commande" syntaxe (git style) sous la forme:

$ executable <command> [options]

par exemple.

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

de la Commande et sous-syntaxe de la commande (menu fixe de style) 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 du Guide d'utilisation

un guide d'utilisation (généralement imprimé lorsque --help est défini) peut être généré en utilisant ligne de commande-usage . Voir les exemples ci-dessous et lire la documentation pour savoir comment les créer.

un exemple typique de guide d'utilisation.

Le polymère-cli guide d'utilisation est un bon exemple.

Autres Lectures

il y a beaucoup plus à apprendre, s'il vous plaît voir le wiki pour des exemples et de la documentation.

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

Yargs est l'un des plus amusantes, 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._);

sortie est ici (il lit des 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 en ligne de commande.

passer, analyser les arguments est un processus facile. Nœud fournit vous avec le processus.la propriété argv, qui est un tableau de chaînes, qui sont les arguments qui ont été utilisés lorsque le noeud a été invoqué. La première entrée du tableau est le Nœud de l'exécutable, et la seconde entrée est le nom de votre script.

si vous exécutez script avec ci-dessous atguments

$ node args.js arg1 arg2

fichier : args.js

console.log(process.argv)

vous obtiendrez un tableau comme

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

without librairies: using Array.prototype.réduire () 151970920"

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

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

auto analyser Boolean & Numéro de

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

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 viens de faire:

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

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'

vous pouvez atteindre les arguments en ligne de commande en utilisant system.args . Et j'utilise la solution ci-dessous pour analyser les arguments dans un objet, de sorte que 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'indice 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.

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 du noeud.exe in your maching (C:\Program Files\nodejs\node.exe') 1519140920"

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

2 : votre premier argument pour le noeud (arg1)

3 : votre deuxième argument à node (arg2)

4 : votre troisième argument à node (arg3)

vos arguments réels commencent le formulaire 2nd index du tableau argv , c'est-à-dire process.argv[2] .

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

Note: naturellement cela échouera lorsque l'argument contient un = . C'est seulement pour un usage très simple.

sans bibliothèques

si vous voulez le faire à la vanille JS / ES6 vous pouvez utiliser la solution suivante

ouvré uniquement en Ndejs > 6 "151990920

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

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

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