Comment gérer les arguments de ligne de commande dans Bash?

Dans Linux, nous utilisons des arguments de ligne de commande comme entrée pour le script bash. Bash peut prendre ces arguments en ligne de commande séquentiellement et les analyser en option. Ces arguments vous permettent d'affecter les actions et la sortie du script dynamiquement.

Vous pouvez configurer ces arguments différemment pour influencer l'entrée et la sortie. C'est pourquoi gérer les args de ligne de commande dans Bash est essentiel, mais de nombreux nouveaux utilisateurs doivent apprendre à le faire. Ainsi, dans ce guide, nous expliquerons différentes façons de gérer les arguments en ligne de commande dans Bash.

Comment gérer les arguments de ligne de commande dans Bash?

Il existe différentes façons de gérer les args de ligne de commande en bash, alors jetons un œil aux informations pour obtenir de brèves informations:

La fonction getOPT

La fonction GetOPT est pratique car elle fournit les options et la syntaxe pour définir et analyser les arguments en bash. Il s'agit d'une fonction intégrée de Linux que vous pouvez utiliser lors de la création d'un fichier de base de données ou d'un rapport dans un format spécifique en fonction des arguments. La fonction getOPT aide à analyser les courts arguments en ligne de commande car il existe deux types d'arguments:

• Arguments courts: Ce sont les arguments à caractre à un seul caractère suivis d'un trait d'union. Par exemple, -a, -l, -h, etc., sont quelques exemples d'arguments uniques.

• Arguments longs: Ce sont les arguments à plusieurs caractères suivis d'un double hyphen. Il existe différents exemples de longs arguments, tels que-tout, -List, -help, etc.

Prenons un exemple où nous gérerons les arguments de ligne de commande à l'aide de l'utilitaire GetOPT. Nous avons créé un script bash nommé «Getopt.sh ”qui contient les informations suivantes:

!/ bac / bash
tandis que Getopts 'A: B: C: D:' Détails; faire
cas "$ Détails" dans
UN)
Echo "Le nom citoyen est $ optarg" ;;
B)
Echo "Citizen Id est $ optarg" ;;
C)
Echo "Le lieu de naissance est $ optarg" ;;
D)
Echo "L'occupation est $ optarg" ;;
*)
sortie 1 ;;
ESAC
fait
Shift "$ (($ optind -1))"
si [ ! -Z 1 $]; alors
écho "État matrimonial 1 $"
autre
écho "pas d'entrées"
sortie 1
Fi
si [ ! -Z 2 $]; alors
Echo "membres de la famille 2 $"
Fi

Maintenant, exécutons le script avec les arguments requis dans l'entrée:

Comme vous pouvez le voir dans l'image ci-dessus, nous exécutons le script avec les fonctions GetOPT uniquement, puis ajoutez des arguments normaux pour obtenir le résultat complet.

En utilisant des drapeaux

Les drapeaux ne sont que des caractères uniques précédés de traits de traits (-). Lorsque nous passons les arguments en utilisant la fonction getOPT, nous utilisons des drapeaux. -a, -b, -c sont quelques exemples de drapeaux. Par exemple, un script nécessite un nom, une pièce d'identité, un lieu, un âge et une occupation d'un citoyen. Par conséquent, nous avons utilisé les drapeaux J, K, L, M, N, pour définir le nom, l'identification, le lieu, l'âge et l'âge du citoyen simultanément:

#!/ bac / bash
Tandis que Getopts j: k: l: m: n: Flag_info
faire
cas "$ flag_info" dans

1. J) Citizenname = $ optarg ;;


2. k) CitizenId = $ optarg ;;


3. l) Place = $ optarg ;;


4. m) Âge = $ optarg ;;


5. n) occupation = $ optarg ;;

ESAC
fait
Echo "Voici les détails entrés:"
Echo "Nom du citoyen: $ Citizennname";
Echo "Citizen Id: $ CitizenId";
Echo "Place: $ place";
écho "âge: $ Âge";
Echo "Occupation: $ Occupation";

Le script donnera le résultat suivant dans le terminal:

./ //

Utilisation de $ @ avec des boucles

La variable «$ @» n'est rien d'autre que le tableau de tous les arguments d'entrée. Nous pouvons transmettre n'importe quel nombre d'entrées en utilisant la variable «$ @». Vous pouvez utiliser cette variable comme une boucle pour itérer dans les arguments. La variable «$ @» est alors utile; Vous ne connaissez pas la taille des entrées et ne pouvez pas prendre les arguments de position. Par conséquent, vous pouvez utiliser le «$ @» plutôt que de définir la fonction Getopt encore et encore. Voici un exemple d'utilisation de boucles et $ @ ensemble dans un script:

#!/ bac / bash
num = ("$ @")
Si [$ # -gt 1]
alors
add = $ (($ num [0] + $ num [1]))
Echo "L'ajout de tous les chiffres est: $ add"
soustraction = $ (($ num [0] - $ num [1] - $ num [2]))
Echo "La soustraction des nombres est: $ soustraction"
multiply = $ (($ num [0] * $ num [1] * $ num [2]))
Echo "La multiplication des nombres est: $ Multiply"
division1 = $ (($ num [0] / $ num [1]))
echo "Division du $ num [0] et $ num [1] est: $ division1"
division2 = $ (($ num [1] / $ num [2]))
echo "Division de $ num [1] et $ num [2] est: $ division2"
division3 = $ (($ num [0] / $ num [2]))
echo "Division de $ num [0] et $ num [2] est: $ division2"
Fi

Le script ci-dessus effectue différents calculs arithmétiques basés sur les arguments en ligne de commande. Par exemple, nous avons entré 50, 35 et 15 comme entrée:

Utilisation de paramètres de position

Vous pouvez accéder aux paramètres positionnels car ils accédent d'abord 1 $, puis 2 $, et ainsi de suite. Par exemple, créons un script qui lit un nom comme le premier argument puis une ville comme la seconde. Cependant, si vous passez la ville d'abord, puis le nom, il considère le nom comme la ville et vice versa. Prenons une plongée plus profonde dans le script suivant pour comprendre ce concept:

#!/ bac / bash
Echo "Voici les détails entrés"
Echo "Nom 1 $"
Echo "City 2 $"

Vous devez ajouter le nom et la ville au moment de l'exécution du script dans le terminal:

Emballer

C'est tout ce que vous devez savoir sur les méthodes pour gérer les arguments de ligne de commande dans Bash. Nous avons expliqué différentes approches que vous pouvez essayer avec les exemples appropriés. Il existe différentes commandes si vous souhaitez ajouter des arguments dans le script. Alors assurez-vous de visiter Linuxhint pour en savoir plus sur eux.