Comment travailler avec des variables dans Bash

Les variables sont essentielles si vous voulez écrire des scripts et comprendre ce que le code que vous êtes sur le point de copier et coller du Web fera sur votre ordinateur Linux. Nous allons vous aider à démarrer !

variables 101

Les variables sont des symboles nommés qui représentent une chaîne ou une valeur numérique. Lorsque vous les utilisez dans des commandes et des expressions, elles sont traitées comme si vous aviez tapé la valeur qu’elles contiennent au lieu du nom de la variable.

Pour créer une variable, il vous suffit de lui donner un nom et une valeur. Vos noms de variables doivent être descriptifs et vous rappeler la valeur qu’ils contiennent. Un nom de variable ne peut pas commencer par un nombre, ni contenir d’espaces. Il peut cependant commencer par un trait de soulignement. En dehors de cela, vous pouvez utiliser n’importe quel mélange de caractères alphanumériques majuscules et minuscules.

Exemples de variables bash

Ici, nous allons créer cinq variables. Le format est de taper le nom, le signe égal =, et la valeur. Notez qu’il n’y a pas d’espace avant ou après le signe égal. Donner une valeur à une variable est souvent appelé attribuer une valeur à la variable.

Nous allons créer quatre variables de chaîne et une variable numérique,

my_name=Dave

my_boost=Linux

him=Popeye

his_boost=Spinach

this_year=2019

À voir la valeur contenue dans une variable, utilisez la echo commande. Vous devez faire précéder le nom de la variable d’un signe dollar $ chaque fois que vous faites référence à la valeur qu’il contient, comme indiqué ci-dessous :

echo $my_name

echo $my_boost

echo $this_year

Utilisons toutes nos variables à la fois :

echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"

Les valeurs des variables remplacent leurs noms. Vous pouvez également modifier les valeurs des variables. Pour affecter une nouvelle valeur à la variable, my_boostvous répétez simplement ce que vous avez fait lorsque vous avez attribué sa première valeur, comme ceci :

my_boost=Tequila

Si vous relancez la commande précédente, vous obtenez maintenant un résultat différent :

echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"

Ainsi, vous pouvez utiliser la même commande qui fait référence aux mêmes variables et obtenir des résultats différents si vous modifiez les valeurs contenues dans les variables.

Nous parlerons de la citation des variables plus tard. Pour l’instant, voici quelques éléments à retenir :

• Une variable entre apostrophes ' est traité comme une chaîne littérale et non comme une variable.
• Variables entre guillemets " sont traités comme des variables.
• Pour obtenir la valeur contenue dans une variable, vous devez fournir le signe dollar $.
• Une variable sans le signe dollar $ fournit uniquement le nom de la variable.

Vous pouvez également créer une variable qui tire sa valeur d’une variable existante ou d’un nombre de variables. La commande suivante définit une nouvelle variable appelée drink_of_the_Year, et lui attribue les valeurs combinées des my_boost et this_year variables :

drink_of-the_Year="$my_boost $this_year"

echo drink_of_the-Year

Comment utiliser les variables bash dans les scripts

Les scripts seraient complètement paralysés sans variables. Les variables offrent la flexibilité qui fait d’un script une solution générale plutôt qu’une solution spécifique. Pour illustrer la différence, voici un script qui compte les fichiers dans le /dev annuaire.

Tapez ceci dans un fichier texte, puis enregistrez-le sous fcnt.sh (pour « nombre de fichiers ») :

#!/bin/bashfolder_to_count=/devfile_count=$(ls $folder_to_count | wc -l)echo $file_count files in $folder_to_count

Avant de pouvoir exécuter le script, vous devez le rendre exécutable, comme indiqué ci-dessous :

chmod +x fcnt.sh

Tapez ce qui suit pour exécuter le script :

./fcnt.sh

Ceci imprime le nombre de fichiers dans le /dev annuaire. Voici comment cela fonctionne:

• Une variable appelée folder_to_count est défini, et il est configuré pour contenir la chaîne « /dev. »
• Une autre variable, appelée file_count, est défini. Cette variable tire sa valeur d’une substitution de commande. C’est la phrase de commande entre parenthèses $( ). Notez qu’il y a un signe dollar $ avant la première parenthèse. Cette construction $( ) évalue les commandes entre parenthèses, puis renvoie leur valeur finale. Dans cet exemple, cette valeur est affectée au file_count variable. Jusqu’au file_count variable est concernée, on lui a passé une valeur à tenir ; il n’est pas concerné par la façon dont la valeur a été obtenue.
• La commande évaluée dans la substitution de commande effectue une ls liste des fichiers dans le répertoire du folder_to_count variable, qui a été définie sur « /dev. » Ainsi, le script exécute la commande « ls /dev ».
• La sortie de cette commande est redirigée vers le wc commande. Le -l (nombre de lignes) option provoque wc à compter le nombre de lignes dans la sortie du ls commande. Comme chaque fichier est répertorié sur une ligne distincte, il s’agit du nombre de fichiers et de sous-répertoires dans le répertoire « /dev ». Cette valeur est attribuée au file_count variable.
• La dernière ligne utilise echo pour afficher le résultat.

Mais cela ne fonctionne que pour le répertoire « /dev ». Comment pouvons-nous faire fonctionner le script avec n’importe quel répertoire ? Tout ce qu’il faut, c’est un petit changement.

Comment utiliser les paramètres de ligne de commande dans les scripts

De nombreuses commandes, telles que ls et wc, prenez les paramètres de la ligne de commande. Ceux-ci fournissent des informations à la commande, afin qu’elle sache ce que vous voulez qu’elle fasse. Si tu veux ls pour travailler sur votre répertoire personnel et également pour afficher les fichiers cachésvous pouvez utiliser la commande suivante, où le tilde ~ et le -a (tous) sont des paramètres de ligne de commande :

ls ~ -a

Nos scripts peuvent accepter des paramètres de ligne de commande. Ils sont référencés comme $1 pour le premier paramètre, $2 comme le second, et ainsi de suite, jusqu’à $9 pour le neuvième paramètre. (En fait, il y a un $0également, mais c’est réservé pour toujours contenir le script.)

Vous pouvez référencer des paramètres de ligne de commande dans un script comme vous le feriez pour des variables normales. Modifions notre script, comme indiqué ci-dessous, et enregistrons-le avec le nouveau nom fcnt2.sh:

#!/bin/bashfolder_to_count=$1file_count=$(ls $folder_to_count | wc -l)echo $file_count files in $folder_to_count

Cette fois, le folder_to_count la variable reçoit la valeur du premier paramètre de la ligne de commande, $1.

Le reste du script fonctionne exactement comme avant. Plutôt qu’une solution spécifique, votre script est maintenant général. Vous pouvez l’utiliser sur n’importe quel répertoire car il n’est pas codé en dur pour fonctionner uniquement avec « /dev ».

Voici comment rendre le script exécutable :

chmod +x fcnt2.sh

Maintenant, essayez-le avec quelques répertoires. Vous pouvez d’abord faire « /dev » pour vous assurer d’obtenir le même résultat qu’avant. Tapez ce qui suit :

./fnct2.sh /dev

./fnct2.sh /etc

./fnct2.sh /bin

Vous obtenez le même résultat (207 fichiers) que précédemment pour le répertoire « /dev ». C’est encourageant et vous obtenez des résultats spécifiques au répertoire pour chacun des autres paramètres de ligne de commande.

Pour raccourcir le script, vous pouvez vous passer de la variable, folder_to_counttout à fait, et juste référence $1 tout au long, comme suit :

#!/bin/bash file_count=$(ls $1 wc -l) echo $file_count files in $1

Travailler avec des variables spéciales

Nous avons mentionné $0, qui est toujours défini sur le nom de fichier du script. Cela vous permet d’utiliser le script pour faire des choses comme imprimer son nom correctement, même s’il est renommé. Ceci est utile dans les situations de journalisation, dans lesquelles vous souhaitez connaître le nom du processus qui a ajouté une entrée.

Voici les autres variables prédéfinies spéciales :

• $#: combien de paramètres de ligne de commande ont été passés au script.
• $@: Tous les paramètres de la ligne de commande passés au script.
• $ ?: L’état de sortie du dernier processus à exécuter.
• $$: L’ID de processus (PID) du script en cours.
• $USER: Le nom d’utilisateur de l’utilisateur exécutant le script.
• $HOSTNAME: nom d’hôte de l’ordinateur exécutant le script.
• $SECONDES: Le nombre de secondes pendant lesquelles le script a été exécuté.
• $ALÉATOIRE: renvoie un nombre aléatoire.
• $LINENO: Renvoie le numéro de ligne actuel du script.

Vous voulez tous les voir dans un seul script, n’est-ce pas ? Tu peux! Enregistrez ce qui suit dans un fichier texte appelé, special.sh:

#!/bin/bashecho "There were $# command line parameters"echo "They are: $@"echo "Parameter 1 is: $1"echo "The script is called: $0"# any old process so that we can report on the exit statuspwdecho "pwd returned $?"echo "This script has Process ID $$"echo "The script was started by $USER"echo "It is running on $HOSTNAME"sleep 3echo "It has been running for $SECONDS seconds"echo "Random number: $RANDOM"echo "This is line number $LINENO of the script"

Tapez ce qui suit pour le rendre exécutable :

chmod +x special.sh

Maintenant, vous pouvez l’exécuter avec un tas de paramètres de ligne de commande différents, comme indiqué ci-dessous.

Variables d’environnement

Bash utilise des variables d’environnement pour définir et enregistrer les propriétés de l’environnement qu’il crée lors de son lancement. Ceux-ci contiennent des informations auxquelles Bash peut facilement accéder, telles que votre nom d’utilisateur, vos paramètres régionaux, le nombre de commandes que votre fichier d’historique peut contenir, votre éditeur par défaut et bien plus encore.

Pour voir les variables d’environnement actives dans votre session Bash, utilisez cette commande :

env | less

Si vous faites défiler la liste, vous en trouverez peut-être certains qu’il serait utile de référencer dans vos scripts.

Comment exporter des variables

Lorsqu’un script s’exécute, il se trouve dans son propre processus et les variables qu’il utilise ne peuvent pas être vues en dehors de ce processus. Si vous souhaitez partager une variable avec un autre script que votre script lance, vous devez exporter cette variable. Nous allons vous montrer comment faire cela avec deux scripts.

Tout d’abord, enregistrez ce qui suit avec le nom de fichier script_one.sh:

#!/bin/bashfirst_var=alphasecond_var=bravo# check their valuesecho "$0: first_var=$first_var, second_var=$second_var"export first_varexport second_var./script_two.sh# check their values againecho "$0: first_var=$first_var, second_var=$second_var"

Cela crée deux variables, first_var et second_var, et il attribue certaines valeurs. Il les imprime dans la fenêtre du terminal, exporte les variables et appelle script_two.sh. Quand script_two.sh se termine et que le flux de processus revient à ce script, il imprime à nouveau les variables dans la fenêtre du terminal. Ensuite, vous pouvez voir s’ils ont changé.

Le deuxième script que nous utiliserons est script_two.sh. C’est le script qui script_one.shappels. Tapez ce qui suit :

#!/bin/bash# check their valuesecho "$0: first_var=$first_var, second_var=$second_var"# set new valuesfirst_var=charliesecond_var=delta# check their values againecho "$0: first_var=$first_var, second_var=$second_var"

Ce deuxième script imprime les valeurs des deux variables, leur affecte de nouvelles valeurs, puis les imprime à nouveau.

Pour exécuter ces scripts, vous devez taper ce qui suit pour les rendre exécutables :

chmod +x script_one.shchmod +x script_two.sh

Et maintenant, tapez ce qui suit pour lancer script_one.sh:

./script_one.sh

Voici ce que nous dit la sortie :

• script_one.sh imprime les valeurs des variables, qui sont alpha et bravo.
• script_two.sh imprime les valeurs des variables (alpha et bravo) telles qu’il les a reçues.
• script_two.sh les change en charlie et delta.
• script_one.sh imprime les valeurs des variables, qui sont toujours alpha et bravo.

Ce qui se passe dans le deuxième script, reste dans le deuxième script. C’est comme si des copies des variables étaient envoyées au deuxième script, mais elles sont supprimées lorsque ce script se termine. Les variables d’origine du premier script ne sont pas modifiées par ce qui arrive aux copies de celles-ci dans le second.

Comment citer des variables

Vous avez peut-être remarqué que lorsque les scripts font référence à des variables, elles sont entre guillemets ". Cela permet aux variables d’être correctement référencées, afin que leurs valeurs soient utilisées lorsque la ligne est exécutée dans le script.

Si la valeur que vous affectez à une variable comprend des espaces, ils doivent être entre guillemets lorsque vous les affectez à la variable. En effet, par défaut, Bash utilise un espace comme délimiteur.

Voici un exemple :

site_name=How-To Geek

Bash voit l’espace avant « Geek » comme une indication qu’une nouvelle commande démarre. Il signale qu’il n’y a pas une telle commande et abandonne la ligne. echo nous montre que le site_name La variable ne contient rien – pas même le texte « How-To ».

Essayez à nouveau avec des guillemets autour de la valeur, comme indiqué ci-dessous :

site_name="How-To Geek"

Cette fois, il est reconnu comme une valeur unique et correctement affecté au site_name variable.

echo est votre ami

Cela peut prendre un certain temps pour s’habituer à la substitution de commandes, à la citation de variables et à la mémorisation du signe dollar.

Avant d’appuyer sur Entrée et d’exécuter une ligne de commandes Bash, essayez-la avec echo devant elle. De cette façon, vous pouvez vous assurer que ce qui va se passer est ce que vous voulez. Vous pouvez également détecter les erreurs que vous avez pu commettre dans la syntaxe.