L'analyse et la transmission d'arguments dans des scripts bash/shell sont assez similaires à la manière dont nous transmettons des arguments aux fonctions dans les scripts Bash. Nous verrons le processus réel de transmission des arguments à un script et examinerons également la manière d'accéder à ces arguments à l'intérieur du script.

Passer des arguments avant d'exécuter

Nous pouvons passer des paramètres juste après le nom du script lors de l'exécution de la commande de l'interpréteur bash. Vous pouvez transmettre des paramètres ou des arguments au fichier. Juste la commande pour exécuter le script normalement en ajoutant la valeur des paramètres directement au script. Chaque paramètre est une valeur séparée par des espaces à transmettre au script shell.

bash scriptname.sh 

La commande ci-dessus exécutera simplement le script sans transmettre les paramètres.

Alors que la commande ci-dessous transmettra les arguments au script.

bash scriptname.sh parameter1 parameter2 parameter3 nth-parameter 

Exécution d'un script bash avec passage de paramètres

La capture d'écran ci-dessus affiche les paramètres transmis au script, comment nous allons procéder, ce que nous expliquerons dans la section suivante. Mais pour le moment, nous pouvons voir que nous avons transmis les paramètres depuis l'extérieur du script en utilisant des variables d'environnement bash. Vous pouvez même utiliser des chaînes et d'autres types de données, mais méfiez-vous des espaces. L'espace blanc fera de la variable un paramètre distinct. Ainsi, pour les chaînes en particulier, veillez à les entourer strictement de guillemets.

Détection des arguments de ligne de commande

Maintenant, nous verrons comment accéder à ces paramètres à l’intérieur du script. Nous utiliserons le nombre de paramètres passés dans l'ordre, c'est-à-dire que pour les premiers paramètres passés, nous analyserons (accéderons) au paramètre en utilisant $1 comme variable. Le premier paramètre est stocké dans la variable $1. De plus, vous pouvez attribuer cette variable à toute autre variable définie par l'utilisateur de votre choix. Pour le nième paramètre passé, vous pouvez utiliser $n pour accéder à ce paramètre particulier. Ici, le nom de la variable commence par 1 car le nom du fichier/script est le 0ème paramètre. Si vous avez plus de 9 paramètres, assurez-vous d'utiliser { } autour du nombre car sans les parenthèses, bash ne verra que 10 $ comme 1 $ et exclura le 0, utilisez donc ${10} et ainsi de suite au lieu de simplement 10 $.

#!/bin/bash echo '1st parameter = $1 ' echo '2nd Parameter = $2 ' 

Le script ci-dessus peut accéder aux paramètres à partir de la ligne de commande/du shell en utilisant les paramètres de position, qui sont 1, 2, 3, etc.

Accéder aux arguments depuis le script.

Comme vous pouvez le voir, nous avons utilisé {} pour accéder aux numéros de variable paramètre à partir de 10. Le script peut être utilisé pour des boucles et des boucles while pour parcourir les paramètres, mais nous en discuterons dans d'autres sections.

Attribuer les arguments fournis à la variable Bash

Nous pouvons également l'attribuer à d'autres variables personnalisées pour rendre le script plus dynamique et l'adapter aux besoins. Bien que le script ci-dessus, une fois exécuté, n'imprimera que deux paramètres, vous pourrez sûrement accéder à plus de paramètres en utilisant la variable comme ordre des paramètres en nombres. Le script peut accéder aux variables de position à partir de la ligne de commande et les utiliser aux endroits requis, partout où cela est nécessaire dans le script.

#!/bin/bash a=$1 b=$2 p=$(($a*$b)) echo 'The product of $a and $b = $p' 

Attribuer les arguments fournis à la variable Bash

Le script ci-dessus accède aux paramètres de position, c'est-à-dire $1 et $2 transmis au script et stocke les variables définies par l'utilisateur pour y accéder ultérieurement et les modifier en conséquence. Nous pouvons également accéder à plus de paramètres en utilisant des méthodes itératives, comme nous le verrons dans les prochaines sections.

Nous avons également la possibilité de vérifier tous les paramètres NULL ou vides transmis à l'aide des indicateurs -z ou -n. À partir de là, nous pouvons vérifier si les paramètres ont été transmis ou non.

#!/bin/bash if [[ -z $1 ]]; then echo 'No parameter passed.' else echo 'Parameter passed = $1' fi 

Vérification des paramètres de position transmis ou non.

Avec ce script, nous pouvons détecter si des paramètres de position ont été transmis ou si rien n'a été transmis. L'indicateur -z vérifie toute variable NULL ou non initialisée dans BASH. L'indicateur -z renvoie vrai si la variable passée est NULL ou non initialisée. Par conséquent, nous pouvons utiliser des instructions If-else de base pour détecter les paramètres transmis.

Nous pouvons également utiliser l'indicateur -n qui renvoie vrai si aucun paramètre n'est passé, nous devons donc utiliser ! pour inverser la situation.

Comme suit :

#!/bin/bash if [[ ! -n $1 ]]; then echo 'No parameter passed.' else echo 'Parameter passed = $1' fi 

Ce script donnera également le même résultat, mais nous utilisons l'indicateur -n au lieu de -z.

Lecture de plusieurs arguments avec une boucle For ou While

Nous pouvons utiliser la variable @ pour accéder à chaque paramètre passé au script via la ligne de commande. C'est une variable spéciale qui contient le tableau de variables dans BASH. Dans ce cas, nous l'utilisons seul, il contient donc le tableau de paramètres de position transmis. Nous pouvons également l'utiliser pour parcourir les paramètres transmis à l'aide de boucles ou d'une boucle while.

#!/bin/bash for i in $@ do echo -e '$i
' done 

Utiliser des boucles et une variable @ pour accéder aux paramètres en tant qu'éléments de tableau.

Nous avons utilisé une boucle for basée sur une plage pour parcourir jusqu'à ce qu'il y ait des éléments dans le tableau @. Nous parcourons simplement le tableau et imprimons l’élément. Nous pouvons simplement l'attribuer, modifier les valeurs et apporter les modifications requises aux paramètres et arguments pour obtenir le résultat souhaité à partir du script.

OU

On peut également imprimer les arguments en utilisant la boucle while et les variables d'environnement de BASH.

#!/bin/bash i=$(($#-1)) while [ $i -ge 0 ]; do echo ${BASH_ARGV[$i]} i=$((i-1)) done 

Utiliser la boucle while pour parcourir les paramètres transmis.

Nous utilisons la variable ' # ' car il contient le nombre de paramètres transmis. Nous initialisons le nombre de paramètres et en retirons un car nous allons utiliser un tableau pour le parcourir. Ainsi, comme d'habitude, l'index du tableau commence à 0. Comme ce tableau est initialisé à partir du dernier élément ou paramètre passé, nous devons décrémenter le compteur jusqu'à 0 pour imprimer chaque paramètre dans l'ordre dans lequel il est passé. Nous utilisons simplement le tableau BASH_ARGV pour accéder aux paramètres et imprimer sa valeur. De plus, à chaque itération, nous diminuons la valeur de i- l'itérateur ou le compteur de un en utilisant les doubles accolades arithmétiques. À partir de là, nous imprimons simplement chaque paramètre transmis au script à l'aide d'une boucle while, comme le montre la capture d'écran de sortie.

Lecture avec les noms de paramètres

Utiliser getopts pour analyser les arguments et les paramètres

Nous pouvons utiliser le programme/commande getopts pour analyser les arguments transmis au script dans la ligne de commande/le terminal en utilisant des boucles et des instructions switch-case.

#!/bin/bash while getopts n:c: option do case '${option}' in n)nation=${OPTARG};; c)code=${OPTARG};; esac done echo 'Nation : $nation' echo 'code : $code' 

Utiliser getopts pour analyser les arguments et les paramètres

En utilisant getopts, nous pouvons attribuer directement les arguments/paramètres de position de la ligne de commande aux variables bash. Cela nous permet de gérer les paramètres de manière agréable et systématique. Dans le script ci-dessus, nous avons utilisé deux arguments pour stocker les variables bash en utilisant la syntaxe getopts, des boucles while et des instructions switch-case.

Impression des valeurs de tous les arguments

Nous pouvons imprimer les arguments passés au script par une simple variable puissante '@' qui stocke tous les paramètres passés.

#!/bin/bash echo 'The arguments passed in are : $@' 

Impression des valeurs de tous les arguments

Accéder au nombre de paramètres passés

Nous pouvons également utiliser la variable '#' pour accéder au nombre de paramètres passés depuis la ligne de commande. La variable # contient essentiellement le nombre de paramètres/arguments qui sont transmis au script.

#!/bin/bash echo 'The number of arguments passed in are : $#' 

Accéder au nombre de paramètres passés

Voici le processus et la spécification de transmission et d'analyse des variables dans le script bash. La logique de déplacement et de modification des variables est entre les mains de l'utilisateur. Il s'agissait simplement d'une démonstration de la transmission et de l'analyse des arguments de la ligne de commande au script pour les rendre plus dynamiques.