Vous espérez que vos scripts shell Linux puissent mieux gérer les options et arguments de la ligne de commande ? Bash getopts permet de lire facilement les options de la ligne de commande. Nous allons vous montrer comment.
Présentation de l’intégré getopts
Il est très simple de passer des valeurs dans les scripts Bash. Vous pouvez appeler votre script depuis la ligne de commande ou depuis un autre programme et donner votre liste de valeurs au nom du script. Vous pouvez également accéder à ces variables à partir de votre script.
Cette situation peut rapidement devenir plus compliquée si des options sont passées à un programme. Les options peuvent être utilisées pour faire référence aux drapeaux, commutateurs et options que des programmes comme ls sont capables de gérer. Elles sont généralement précédées d’un tiret « -« , et agissent comme des indicateurs pour le programme qui activeront/désactiveront un aspect spécifique de sa fonctionnalité.
Comment utiliser la commande ls de Linux pour lister les fichiers et les répertoires ?
La commande ls fournit plus de 50 options pour formater votre sortie. L’option X (sort by extensions) trie la sortie par ordre alphabétique en fonction de l’extension du fichier. L’option unsorted (non trié) liste les résultats par ordre de répertoire.
Les options ne sont rien d’autre que des options. Il est impossible de prévoir quelles options (le cas échéant) l’utilisateur choisira d’utiliser et dans quel ordre il les énumérera. Cela complique le code pour traiter les options.
Vous pouvez rendre les choses plus compliquées si vous donnez un argument à certaines options. C’est ce qu’on appelle un argument d’option. Bien sûr, d’autres paramètres peuvent être passés dans votre script, qui peuvent être simplement des valeurs de données.
Il est facile de gérer cette complexité avec getopts. Vous n’avez même pas besoin de l’installer car il s’agit d’une fonction intégrée au shell Bash.
Il est impératif de protéger les fichiers Shell Linux.
Note : getopts n’est pas getopt
Il existe également un utilitaire plus ancien appelé getopt. Ce programme n’est pas une barre d’outils, mais plutôt un programme utilitaire. Il existe de nombreuses versions et options de comportement pour getopt. Le getops-builtin est conforme aux directives POSIX.
type getopt
Pour voir les différences entre getops et getopt, utilisez la commande type
Getopt n’est pas une fonctionnalité intégrée et n’offre donc pas les mêmes avantages automatiques que getopts. Par exemple, getopt ne gère pas les espaces de manière raisonnable. Avec getopts, le shell Bash exécutera votre script tandis que le shell Bash se chargera de l’analyse des options. Pour effectuer l’analyse, vous n’avez pas besoin d’invoquer un autre programme.
Il n’est pas capable de gérer les noms d’options de format long avec des caractères à double tiret. Les options peuvent donc être utilisées comme —wide-format mais pas -w.
Nous allons discuter et faire la démonstration de getopts dans cet article.
Un bref rappel : Gestion des valeurs des paramètres
Ce script n’utilise PAS les options en pointillés comme « -a » ou « -b ». Il accepte les paramètres « normaux » de la ligne de commande. Ils sont accessibles dans ce script sous forme de valeurs.
!/bin/bash
Récupère toutes les variables une par une
echo « Variable One : $1 »
echo « Variable Deux : $2 »
echo « Variable Three : $3 »
Boucle à travers les variables
for var « $@ »
echo « $var »
Faites-le
Les paramètres sont accessibles dans le script en tant que variables $2, $3 ou $1.
Copiez le texte et enregistrez-le dans un éditeur. Cette étape est nécessaire pour tous les scripts abordés. Remplacez simplement le nom du script à chaque fois.
chmod +x variables.sh
Vous pouvez rendre un programme exécutable en utilisant les commandes chmod
Si vous exécutez votre script sans paramètres, vous obtiendrez la sortie suivante.
./variables.sh
Un script s’exécutant sans paramètres
Le script n’a passé aucun paramètre. Donnons quelques paramètres.
./variables.sh : comment devenir un geek
Exécution d’un script avec trois mots comme paramètres
Comme prévu, nous voyons que les paramètres $1, $3, et $2 ont été assignés à ces variables.
Ce type de gestion des paramètres un pour un nous oblige à savoir à l’avance combien de paramètres nous aurons besoin. La boucle à la fin du script ne se soucie pas du nombre de paramètres. Elle se contente de les passer tous en boucle.
Un quatrième paramètre peut être fourni, mais il ne sera pas affecté à une variable. Cependant, la boucle le traitera quand même.
./variables.sh Site Web
Passage de quatre paramètres à un script qui ne peut en gérer que trois
Il est possible de placer des guillemets autour de 2 mots. Ils seront traités comme un seul paramètre.
./variables.sh Comment » to geek » (en anglais)
Il est possible de mettre entre guillemets deux paramètres de ligne de commande pour qu’ils soient considérés comme un seul paramètre
Si nos scripts doivent gérer toutes les combinaisons, options avec options et paramètres « normaux » de type données, nous devons distinguer les options des paramètres normaux. Toutes les options peuvent être placées avant le paramètre régulier, sans ou avec des arguments.
Mais il ne faut pas courir avant de marcher. Commençons par le cas le plus élémentaire de la gestion des options en ligne de commande.
Manipulation des options
Dans une boucle while, on utilise getopts. Chaque itération travaille sur une option donnée au script. Dans chaque cas, la variable « OPTION » est définie comme l’option donnée par getopts.
getopts change l’option pour chaque itération. S’il n’y a pas de choix, getopts renvoie false.
Scripts Bash Case Statements : Comment les utiliser
Les variables OPTION sont comparées à chacune des clauses de l’instruction case. L’instruction case est utilisée pour que l’ordre des options sur les lignes de commande n’ait pas d’importance. Chaque option est placée dans l’instruction cas, puis la clause appropriée est activée.
Vous pouvez effectuer des actions spécifiques dans le script en utilisant chaque clause des instructions case. Dans les scripts du monde réel, vous placez généralement une variable dans chaque clause. Ces variables agiraient comme des drapeaux plus loin dans le script, autorisant ou refusant certaines fonctionnalités.
Ce texte doit être copié dans un éditeur. Vous pouvez l’enregistrer sous le nom de « options.sh » pour le rendre exécutable.
!/bin/bash
while getopts ‘abc’ OPTION ; do
si « $OPTION », dans
a)
echo « Option a utilisée » ; ;
b)
echo « Option b utilisée » ;; ; b)
; ;
c)
echo « Option c utilisée » ;; ; c)
; ;
?)
echo « Usage : $(basename $0) [-a] [-b] [-c] »
Entrer à 1
; ;
esac
Faites-le
C’est ce qui définit la boucle while.
while getopts ‘abc’ OPTION ; do
La chaîne d’options se trouve à côté de la commande getopts. Elle liste toutes les lettres que nous allons utiliser pour les options. Seules les lettres de cette liste peuvent être utilisées pour créer des options. Cela signifie que -d dans cet exemple ne serait pas valide. Cette clause serait verrouillée par la commande ? Cette clause serait alors verrouillée par la clause ????. getopts renvoie » ? » comme point d’interrogation pour une option non identifiée. Si cela se produit, l’utilisation correcte de l’option est affichée dans la fenêtre du terminal.
echo « Usage : $(basename $0) [-a] [-b] [-c] »
Il est d’usage de placer une option entre des parenthèses « [] » afin qu’elle puisse être utilisée dans un message d’utilisation correct. Basename supprime tout chemin de répertoire d’un nom de fichier. Le nom de fichier du script est enregistré dans $0 dans BashScripts.
Changeons les combinaisons de la ligne de commande et utilisons ce script.
./options.sh -a
./options.sh -a -b -c
./options.sh -ab -c
./options.sh -cab
Un script qui prend en charge les options des lignes de commande de type switch peut être testé.
Comme vous pouvez le voir, toutes les combinaisons de test des options possibles sont correctement analysées. Que faire si nous voulons essayer une option qui n’est pas là ?
./options.sh -d
Les options non reconnues sont signalées par le shell et le script.
Alors que la clause d’utilisation est activée, elle est également bonne. Cependant, nous recevons également un message d’erreur par le shell. Cela peut ou non affecter votre cas d’utilisation. Si vous appelez le script en utilisant un autre script qui doit analyser les codes d’erreur, cela rendra les choses plus difficiles si le shell génère des messages d’erreur.
Il est simple de désactiver les messages d’erreur de l’interpréteur de commandes. Il suffit de mettre deux points entre » : » et le premier caractère d’une chaîne d’options.
Modifiez le fichier « options.sh » en ajoutant deux points après la chaîne d’options. Vous pouvez également enregistrer ce script sous le nom de « options2.sh » et le rendre exécutable.
!/bin/bash
while getopts ‘:abc’ OPTION ; do
si « $OPTION », dans
a)
echo « Option a utilisée »
; ;
b)
echo « Option b utilisée » ;; ; b)
; ;
c)
echo « Option c utilisée » ;; ; c)
; ;
?)
echo « Usage : $(basename $0) [-a] [-b] [-c] »
Entrer à 1
; ;
esac
Faites-le
Si nous exécutons cette commande et qu’elle génère une erreur, nous obtenons nos propres messages d’erreur. Il n’y a pas de messages de l’interpréteur de commandes.
./options2.sh.sh -d
Option non reconnue qui est signalée par le script seul
Getopts avec des arguments d’option
Si vous voulez informer getopts d’une option qui sera suivie d’un objet, placez un deux-points ( » : « ) immédiatement après les lettres de l’option dans la chaîne d’options.
Si nous incluons les lettres « b », « c », et « c, » dans notre chaîne d’options, alors getopt attendra des arguments pour ces options. Copiez le script suivant dans votre éditeur. Sauvegardez-le sous le nom de « arguments.sh » et rendez-le exécutable.
Le premier deux-points de la chaîne d’options sert à supprimer les erreurs de l’interpréteur de commandes et n’a rien à dire sur le traitement des arguments.
Quand getopt traite une option qui a un argument, il place l’argument dans la variable OPTARG. Copiez cette valeur dans une autre variable afin de l’utiliser dans d’autres scripts.
!/bin/bash
while getopts ‘:ab:c:’ OPTION ; do
case « $OPTION ») in
a)
echo « Option a utilisée »
; ;
b)
argB= »$OPTARG »
echo « Option b utilisée avec $argB » ;; ; b)
; ;
c)
argC= »$OPTARG »
echo « Option c avec : $argC
; ;
?)
echo « Utilisation : $(basename $0) [-a] [-b argument] [-c argument] »
Entrez à 1
; ;
esac
Faites-le
Faisons ceci et voyons comment cela se passe.
./arguments.sh
./arguments.sh -c reviewgeek -a
Un script qui prend en charge les arguments des options peut être testé
Cela nous permet de gérer les options avec ou sans argument, quelle que soit la façon dont elles sont présentées sur les lignes de commande.
Mais qu’en est-il des paramètres réguliers ? Nous avons déjà dit que les paramètres réguliers devaient être ajoutés à la ligne de commande après toute autre option. Voyons ce qui se passe dans ce cas.
Mélange d’options et de paramètres
Nous allons modifier notre script précédent pour ajouter une ligne supplémentaire. Nous accéderons aux paramètres réguliers une fois que la boucle while aura fini de sortir et que toutes les options auront été traitées. Nous imprimerons la valeur comme $1.
Enregistrez le script sous le nom de « arguments2.sh », puis rendez-le exécutable.
!/bin/bash
while getopts ‘:ab:c:’ OPTION ; do
cas « $OPTION ».
a)
echo « Option a utilisée »
; ;
b)
argB= »$OPTARG »
echo « Option b avec : $argB
; ;
c)
argC= »$OPTARG »
echo « Option c avec : $argB $argC
; ;
?)
echo « Utilisation : $(basename $0) [-a] [-b argument] [-c argument] »
Entrez à 1
; ;
esac
Faites-le
echo « La variable 1 est : $1 ».
Maintenant, nous allons tester quelques combinaisons et paramètres.
./arguments2.sh dave
./arguments2.sh
./arguments2.sh -a -c to-geek dave
Vous ne pouvez pas accéder aux paramètres standard dans les scripts qui acceptent des arguments d’option.
Voici comment on peut voir le problème. Lorsque des options sont utilisées, les variables à partir de $1 contiennent les drapeaux d’option avec leurs arguments. Si vous ne savez pas combien d’arguments et d’options seront utilisés, $4 contiendrait « dave ». Cependant, cet exemple montre comment vous pouvez accéder à la valeur du paramètre.
Réponse : Utilisez OPTIND avec la commande shift.
La commande shift élimine le premier paramètre – quel que soit son type – de la liste des paramètres. Les autres paramètres sont « mélangés », ainsi le paramètre 2 devient le paragraphe 1, le paramètre 3, devient le paramètre 2, etc. Ainsi, $2 devient $1, $3 devient 2 et ainsi de suite.
Si vous spécifiez shift par un nombre, il retirera ce nombre de paramètres de la liste.
OPTIND compte les options et les arguments au fur et à mesure qu’ils deviennent disponibles et qu’ils sont traités. OPTIND calculera le nombre d’options et d’arguments une fois que tous auront été traités. En retirant les paramètres OPTIND-1 (shift to trim) des listes de paramètres, nous aurons les paramètres réguliers commençant à $1.
C’est exactement le but de ce script. Ce script doit être sauvegardé dans « arguments3.sh » pour pouvoir être exécuté.
!/bin/bash
while getopts ‘:ab:c:’ OPTION ; do
Dans le cas de « $OPTION »,
a)
echo « Option a utilisée »
; ;
b)
argB= »$OPTARG »
echo « Option b utilisée avec $argB » ;; ; b)
; ;
c)
argC= »$OPTARG »
echo « Option c avec : $argC
; ;
?)
echo « Utilisation : $(basename $0) [-a] [-b argument] [-c argument] »
Entrez à 1
; ;
esac
Faites-le
echo « Before – variable one : $1 »
« shift « $(($OPTIND) »
Echo « Après – la variable un est : $1
Echo « Le reste des arguments (opérandes).
« $@ »
Faites
echo $x
Faites-le
Nous allons l’exécuter avec une variété d’options, d’arguments, de paramètres.
./arguments3.sh
Accéder correctement aux arguments des options dans un script qui accepte les paramètres standard.
Comme vous pouvez le voir, avant d’appeler « shift », $1 contenait « a », mais après la commande shift, $1 contient notre premier paramètre non optionnel, sans argument. Il est aussi facile de parcourir en boucle tous les paramètres d’un script sans analyse des options que ceux d’un script.
C’est toujours une bonne idée d’avoir des options
Il n’est pas difficile de gérer les options ou leurs arguments dans les scripts. Avec getopts, vous pouvez créer des scripts pour gérer les options de la ligne de commande, les arguments et les paramètres d’une manière qui est compatible avec POSIX.