Comment passer des arguments de ligne de commande à un programme Node.js?
J'ai un serveur Web écrit dans Node.js et j'aimerais lancer avec un dossier spécifique. Je ne sais pas comment accéder aux arguments en JavaScript. J'exécute le noeud comme ceci:
$ node server.js folder
ici, server.js est le code de mon 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 pu trouver cette information sur le Web.
Méthode standard (pas de bibliothèque)
Les arguments sont stockés dans process.argv
Voici les documents de 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 "noeud", le deuxième é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 va générer:
$ 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 le ferait une fonction javascript normale, 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 représente l'emplacement du script que vous exécutez.
La réponse right à jour lui permet d'utiliser la bibliothèque minimist . Nous avions l'habitude d'utiliser 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 de l'argument javascript Vanilla:
const args = process.argv;
console.log(args);
Cela retourne:
$ node server.js one two=three four
['node', '/home/server.js', 'one', 'two=three', 'four']
Les packages NPM les plus utilisés pour l'analyse des arguments:
Minimist: Pour l'analyse syntaxique minimale.
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 matures/interactives en ligne de commande avec analyse des arguments.
Optimiste (optimiste de noeud)
Consultez la bibliothèque optimist , c'est bien mieux que d'analyser manuellement les options de ligne de commande.
Mettre à jour
Optimist est obsolète. Essayez yargs qui est un fork actif 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 d'argument et il est déjà fourni en standard avec node.js, comme MooGoo l'a fait remarquer ...
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.
promptement
Fonctionne très bien pour obtenir les commentaires 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 du générateur.
Stdio Library
La méthode la plus simple pour analyser les arguments de ligne de commande dans NodeJS consiste à utiliser le module stdio . Inspiré par l’utilitaire UNIX getopt, c’est aussi simple que cela:
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 prises en charge, vous pouvez donc é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 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 est également affiché si une option obligatoire n'est pas spécifié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 stdio module en utilisant NPM :
npm install stdio
Si votre script s'appelle myScript.js et que vous souhaitez passer le nom et le prénom "Sean Worthington", comme arguments 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'
command-line-args mérite le détour!
Vous pouvez définir des options en utilisant les normes de notation principales ( pour en savoir plus ). Ces commandes sont toutes équivalentes, en 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, commencez par créer une liste de définitions d’options décrivant les options acceptées par votre application. La propriété type est une fonction de définition (la valeur fournie est transmise par celle-ci), vous permettant de contrôler totalement 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
}
Utilisation avancée
Outre l'utilisation typique ci-dessus, vous pouvez configurer les 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 de commande et sous-commande (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 guides d'utilisation
Un guide d'utilisation (généralement imprimé lorsque --help est défini) peut être généré à l'aide de commande-line-usage . Voir les exemples ci-dessous et lisez la documentation pour savoir comment les créer.
Un exemple typique de guide d'utilisation.
Le guide d'utilisation de polymer-cli est un bon exemple concret.
Lectures complémentaires
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. Eh bien, plus d'un, probablement des centaines.
Yargs est l’un des plus amusants, ses documents sont sympas à 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' ]
Pas de bibliothèque avec des drapeaux formatés dans 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('=')
args[longArg[0].slice(2,longArg[0].length)] = longArg[1]
}
// 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
Simple
contribution
node test.js -D --name=Hello
sortie
{ D: true, name: 'Hello' }
Monde réel
contribution
node config/build.js -lHRs --ip=$Host --port=$PORT --env=dev
sortie
{ l: true,
H: true,
R: true,
s: true,
ip: '127.0.0.1',
port: '8080',
env: 'dev' }
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' }
également,
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 le booléen et le nombre
console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' }
C'est probablement une bonne idée de gérer votre configuration de manière centralisée en utilisant quelque chose comme nconfhttps://github.com/flatiron/nconf
Il vous aide à utiliser les fichiers de configuration, les variables d’environnement et les arguments de ligne de commande.
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 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 atéguments ci-dessous
$ node args.js arg1 arg2
Fichier: args.js
console.log(process.argv)
Vous obtiendrez tableau comme
['node','args.js','arg1','arg2']
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 =. Ceci est seulement pour un usage très simple.
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 de ligne de commande en utilisant system.args. Et j'utilise la solution ci-dessous pour analyser les arguments dans un objet, afin que je puisse obtenir lequel je veux par 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 comme args.whatever
Remarque: vous devez utiliser des arguments nommés tels que
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;
}
Alors juste faire:
var arguments = require('./parse-cli-arguments')(['foo', 'bar', 'xpto']);
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 machine (C:\Program Files\nodejs\node.exe ')
1: Le répertoire de votre fichier de projet. (proj.js)
2: votre premier argument au noeud (arg1)
3: votre deuxième argument au noeud (arg2)
4: votre troisième argument au noeud (arg3)
vos arguments réels commencent sous la forme 2nd index du tableau argv, c'est-à-dire process.argv[2].
Sans bibliothèques
Si vous voulez faire cela 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
p.s. Veuillez corriger le code sur la carte et réduire la fonction Si vous trouvez une solution plus élégante, merci;)
Le moyen le plus simple de récupérer des arguments dans Node.js consiste à utiliser le tableau process.argv. C'est un objet global que vous pouvez utiliser sans importer aucune bibliothèque supplémentaire pour l'utiliser. Vous devez simplement 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 noeud. 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 qui a été 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 script ne fait que parcourir le tableau process.argv et imprimer les index, ainsi que les éléments stockés dans ces index. C'est très utile pour le débogage si vous vous interrogez sur les arguments que vous recevez et dans quel ordre.
Vous pouvez également utiliser des bibliothèques telles que yargs pour utiliser des arguments commnadline.
Bien que les réponses ci-dessus soient parfaites, et que quelqu'un ait déjà suggéré yargs, l'utilisation du package est très simple . Il s'agit d'un package Nice permettant de passer des arguments à la ligne de commande très facilement.
npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);
Veuillez visiter https://yargs.js.org/ pour plus d’informations.
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 parcourir 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
Le meilleur moyen de passer des arguments de ligne de commande à un programme Node.js consiste à utiliser une interface de ligne de commande (CLI)
Vous pouvez utiliser un module nifty npm appelé nodejs-cli .
Si vous voulez en créer un sans dépendance, j'en ai un sur mon Github si vous voulez le vérifier, c'est en fait assez simple et facile à utiliser, cliquez ici .
comme indiqué dans la documentation du noeud La propriété process.argv renvoie un tableau contenant les arguments de ligne de commande passés 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}`);
});
Lancer le 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
process.argv étant votre ami, la capture d'arguments en ligne de commande est prise en charge de manière native dans Node JS. Voir exemple ci-dessous ::
process.argv.forEach((val, index) => {
console.log(`${index}: ${val}`);
})
Passer des arguments est facile, et les recevoir n’est qu’une question de lecture du processus.argv array Un noeud rend accessible de l’ensemble, en gros. Mais vous êtes sûr de vouloir les lire comme des paires clé/valeur, vous aurez donc besoin d'un script pour pouvoir les interpréter.
Joseph Merdrignac en a publié un beau utilisant une réduction, mais il s’appuyait sur une syntaxe key=value au lieu de -k value et --key value. Je l'ai réécrit beaucoup plus moche et plus longtemps pour utiliser cette seconde norme, et je la posterai en tant que réponse car elle ne correspondrait pas à 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 foxtrot vous 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"
}