Comment analyser les arguments en ligne de commande en Node.js

0 commentaire

Un exemple de comment analyser les paramètres passés à une commande dans un invité de commande. Une traduction de l'article How to parse command line arguments

Classé dans Ligne de commande

Traduction

Le passage d'arguments via la ligne de commande est une tâche de programmation extrêmement basique, et une nécessité pour quiconque essaie d'écrire une interface en ligne de commande (CLI) simple. Dans Node.js, comme en C et dans de nombreux environnements similaires, tous les arguments de la ligne de commande reçus par l'invité de commande sont donnés au processus dans un tableau appelé argv (abréviation de argument values).

Node.js expose ce tableau pour chaque processus en cours sous la forme de process.argv ; regardons un exemple. Créez un fichier appelé argv.js et ajoutez cette ligne :

console.log(process.argv);

Maintenant, sauvegardez-le, et essayez ce qui suit dans votre invité de commande :

$ node argv.js un deux trois quatre cinq
[ 'node',
  '/home/avian/argvdemo/argv.js',
  'un',
  'deux',
  'trois',
  'quatre',
  'cinq' ]

Et voilà, un tableau contenant tous les arguments que vous avez passés. Remarquez les deux premiers éléments ; node et le chemin d'accès à votre script. Ils seront toujours présents, même si votre programme ne prend aucun argument, l'interpréteur et le chemin de votre script sont toujours considérés comme des arguments pour l'invité de commande que vous utilisez.

En ce qui concerne les arguments quotidiens du CLI, vous pouvez ignorer les deux premiers. Maintenant, essayez ceci dans argv.js :

var myArgs = process.argv.slice(2);
console.log('myArgs : ', myArgs);

Cela donne :

$ node argv.js one two three four five
myArgs :  [ 'un', 'deux', 'trois', 'quatre', 'cinq' ]

Maintenant, faisons quelque chose avec les arguments :

var myArgs = process.argv.slice(2);
console.log('myArgs : ', myArgs);

switch (myArgs[0]) {
case 'insulte':
    console.log(myArgs[1], 'Ça sent pas bon.');
    break;
case 'compliment':
    console.log(myArgs[1], 'C'est vraiment cool.');
    break;
default:
    console.log('Désolé, ce n'est pas quelque chose que je sais faire.');
}

Conseil : n'oubliez pas de faire une pause break après chaque cas case ; sinon, vous exécuterez aussi le cas suivant !

Se référer aux arguments de la ligne de commande par l'index du tableau n'est pas très propre, et peut rapidement devenir un cauchemar quand vous commencez à travailler avec des drapeaux et autres. Imaginez que vous faites un serveur, et qu'il a besoin de beaucoup d'arguments. Imaginez avoir à gérer quelque chose comme myapp -h host -p port -r -v -b --quiet -x -o outfile ; certains drapeaux ont besoin de savoir ce qui vient ensuite, d'autres non, et la plupart des CLI laissent les utilisateurs spécifier les arguments dans l'ordre qu'ils veulent. Cela ressemble à une chaîne de caractères amusante à analyser ?

Heureusement, il existe de nombreux modules tiers qui rendent tout cela trivial ; l'un d'entre eux est yargs (EN). Il est disponible via npm. Utilisez cette commande à partir du chemin de base de votre application :

npm i yargs

Une fois que vous l'avez, essayez-le ; il peut vraiment vous sauver la vie. Testons-le en nous amusant à vérifier l'année bissextile et à lire l'heure actuelle.

const yargs = require('yargs');

const argv = yargs
    .command('lyr', 'Indique si une année est bissextile ou non.', {
        year: {
            description: 'l'année à vérifier',
            alias: 'y',
            type: 'number',
        }
    })
    .option('time', {
        alias: 't',
        description: 'Indiquer le temps présent',
        type: 'boolean',
    })
    .help()
    .alias('help', 'h')
    .argv;

if (argv.time) {
    console.log('The current time is: ', new Date().toLocaleTimeString());
}

if (argv._.includes('lyr')) {
    const year = argv.year || new Date().getFullYear();
    if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
        console.log(`${year} est une année bissextile`);
    } else {
        console.log(`${year} n'est PAS une année bissextile`);
    }
}

console.log(argv);

La dernière ligne a été incluse pour vous permettre de voir comment yargs gère vos arguments. Voici une référence rapide :

  • argv.$0 contient le nom du fichier de script qui est exécuté comme : '$0': 'myapp.js'.
  • argv._ est un tableau contenant chaque élément qui n'est pas attaché à une option (ou un drapeau), ces éléments sont appelés des commands dans yargs.
  • Les options individuelles (drapeaux) deviennent des propriétés de argv, comme avec argv.h et argv.time. Notez que les drapeaux qui ne sont pas à une lettre doivent être passés en tant que --flag comme : node myapp.js --time.

Un résumé des éléments utilisés dans le programme :

  • argv : C'est le process.argv modifié que nous avons configuré avec yargs.
  • command() : Cette méthode est utilisée pour ajouter des commandes, leur description et les options qui sont spécifiques à ces commandes seulement, comme dans le code ci-dessus lyr est la commande et -y est l'option spécifique à lyr : node myapp.js lyr -y 2016
  • option() : Cette méthode est utilisée pour ajouter des options globales (flags) qui peuvent être accédées par toutes les commandes ou sans aucune commande.
  • help() : Cette méthode est utilisée pour afficher un dialogue d'aide lorsque l'option --help est rencontrée, qui contient une description de toutes les commands et options disponibles.
  • alias() : Cette méthode fournit un nom d'alias à une option, comme dans le code ci-dessus --help et -h déclenchent tous deux le dialogue d'aide.

Pour plus d'informations sur yargs et les nombreuses autres choses qu'il peut faire pour vos arguments de ligne de commande, veuillez consulter le site officiel (EN).

Lire dans une autre langue