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.

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

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.

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

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.

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.

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"

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.

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

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

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'

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.

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

Lectures complémentaires

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

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

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.

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.

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

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

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'

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

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.

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

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

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.

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

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.

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

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

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

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

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 .

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