Un guide simple pour le scripting Shell Linux avec Bash

Vous êtes-vous déjà trouvé à vouloir en savoir plus sur le scripting shell Linux, mais vous ne saviez pas par où commencer ? Êtes-vous relativement nouveau dans le monde des systèmes d’exploitation basés sur Unix et souhaitez étendre vos compétences pour faire de la programmation shell de base ? Ce tutoriel pour débutants abordera les bases du scripting shell Linux avec Bash, y compris la création et l’exécution d’un script, ainsi que le travail avec des chaînes de caractères et des boucles.

Le scripting shell est utilisé pour automatiser des tâches administratives courantes

Quel que soit le système d’exploitation, les scripts shell sont utilisés pour automatiser des tâches administratives répétitives. Par exemple, sous Windows, vous pouvez renommer des fichiers à l’aide de l’Explorateur de fichiers. Mais si vous devez renommer de nombreux fichiers, cela serait une tâche chronophage en utilisant l’interface graphique. PowerShell vous permet d’automatiser la tâche et de la répéter de manière fiable.

Dans les systèmes d’exploitation basés sur Linux, Bash et d’autres shells sont utilisés pour automatiser des tâches telles que le travail avec des fichiers, la modification de la configuration système, et de nombreuses autres tâches qui pourraient autrement être effectuées en tapant des commandes simples.

Ce dont vous avez besoin pour apprendre le scripting shell Bash

Pour écrire et exécuter un script Bash, vous avez seulement besoin de trois choses :

• Tout éditeur de texte simple, comme Notepad, Text Editor, TextEdit, vi, emacs ou Visual Studio Code.
• A terminal emulator, an application that comes preinstalled with most operating systems and is often called Terminal, Console, or Command Prompt.
• Bash lui-même.

L’émulateur de terminal est l’endroit où vous tapez les commandes et les exécutez en appuyant sur Entrée ou Retour. En ce qui concerne Bash, s’il est préinstallé dépend de votre plateforme :

• Sur macOS, Bash est préinstallé. Sur les versions plus récentes, le Z shell (zsh) est le shell par défaut, et c’est ok. Tant que Bash est installé, vous pouvez également exécuter des scripts Bash à partir de zsh.
• Les distributions Linux ont généralement Bash installé. (Vous pouvez vérifier en regardant si votre système inclut le fichier /bin/bash.) Android est un cas particulier qui n’embarque pas Bash. Il existe des étapes pour installer Bash sur Android, auxquelles cet article ne s’attardera pas.
• Windows ne vient pas avec Bash préinstallé. PowerShell est l’interpréteur de commandes par défaut dans Windows. Vous devrez installer une distribution Linux sous le Windows Subsystem for Linux (WSL) pour exécuter Bash.

Pour trouver la version de votre Bash, exécutez la commande bash –version. Même les anciennes versions de Bash vous offrent beaucoup de puissance, mais Bash 3 et 4 introduisent des notations abrégées pratiques pour certaines commandes de base. Si une commande nécessite l’une de ces versions de Bash, elle sera mentionnée ci-dessous.

Qu’est-ce qu’un shell ?

Dans le monde de l’informatique, un shell est un programme qui sert d’interface pour le système d’exploitation sous-jacent. Un shell peut être une interface utilisateur graphique (GUI), comme le shell Windows.

Langages de script shell

Cependant, les gens utilisent généralement le terme pour se référer spécifiquement à une interface en ligne de commande (CLI) – une interface composée de lignes de texte avec lesquelles vous interagissez uniquement à l’aide du clavier. Voici quelques exemples de langages de script shell pour les systèmes d’exploitation *nix :

• le shell Bash (abrégé de  » Bourne Again Shell »)
• le shell C
• le shell Korn

Ici, nous nous concentrerons sur le shell Bash. C’est un shell Unix gratuit populaire préinstallé sur la plupart des distributions Linux et sur macOS.

Qu’est-ce qu’un script shell ?

Les shells ont leur propre langage de programmation. Vous utilisez ce langage pour envoyer des commandes au shell, qui les exécute ensuite. Vous pouvez taper ces commandes directement dans le shell, ou vous pouvez les enregistrer dans un fichier – un script – et ensuite exécuter ce fichier à partir du shell. La syntaxe pour rédiger des commandes est la même dans les deux cas.

Cet article couvrira les bases du scripting shell pour créer ce fichier.

Scripting shell de base

Commençons par quelques bases du scripting shell. Pour écrire un script simple, nous allons apprendre quelques commandes de scripting shell simples sous Linux :

1. Créez un nouveau fichier texte vide dans un éditeur de texte.
2. Écrivez #!/bin/bash comme première ligne.
3. Tapez vos commandes en dessous.
4. Enregistrez le fichier, de préférence avec une extension « .sh » ou sans extension du tout.

La ligne #!/bin/bash est appelée « un shebang. » Cela indique à votre shell que ce script doit être exécuté dans Bash et doit être la première ligne de votre script. Si vous passez à un shell différent, votre script sera toujours exécuté dans Bash.

Pour tester ce processus vous-même, créez un fichier appelé « hello_world » dans votre répertoire personnel:

#!/bin/bash
echo "hello world"

C’est tout – vous avez créé un script Bash!

Avant de pouvoir l’exécuter, vous devrez probablement modifier les autorisations sur le fichier.

Définir les autorisations pour exécuter un script shell en utilisant chmod

Pour modifier les autorisations sur notre fichier « hello_world », vous exécuteriez cette commande spécifique dans votre émulateur de terminal. Cela donne à l’utilisateur qui possède le fichier la permission d’exécuter le fichier.:

chmod u+x 'hello_world'

Si vous souhaitez simplement exécuter votre script shell, vous pouvez passer à la section suivante. Pour ceux qui sont curieux au sujet de la commande chmod, chmod est l’abréviation de « change mode » et sert à modifier les « modes » (ou autorisations) des fichiers sous Unix. Dans les systèmes d’exploitation de type Unix, vous pouvez définir les permissions des fichiers pour 3 classes d’utilisateurs :

• L’utilisateur propriétaire du fichier (représenté par u dans chmod).
• Le groupe propriétaire du fichier (g).
• Les autres (o).

Avec la commande chmod, vous pouvez également utiliser a pour faire référence à tous ces utilisateurs.

Chaque fichier a 3 types de permissions (ou « modes ») :

• Lecture (r)
• Écriture (w)
• Exécution (x)

Et vous pouvez également ajouter (+) ou retirer (-) des autorisations.

Le premier paramètre dans chmod est une combinaison de ces trois – utilisateur d’abord, action ensuite, et mode en dernier. Voici quelques exemples de commandes :

• chmod gu+rw 'hello_world' ajouterait les autorisations de lecture et écriture pour le propriétaire et le groupe propriétaire.
• chmod a-x 'hello_world' retirerait les autorisations d’exécution pour tout le monde.
• chmod u+rwx 'hello_world' 'hello_world_2' donnerait au propriétaire la permission de lire, écrire et exécuter les fichiers « hello_world » et « hello_world_2 ».

Nous avons seulement couvert les bases de la commande chmod ici. Il y a aussi une façon plus compliquée, mais moins verbeuse, de définir ces modes (la « notation numérique »), ainsi qu’une autre commande que vous pouvez utiliser pour voir quelles permissions ont vos fichiers (ls -l). Nous n’aborderons pas ces sujets ici.

Exécution d’un script shell

Il est temps d’exécuter notre premier script. En général, pour exécuter un script, tapez simplement son chemin dans l’émulateur de terminal et appuyez sur Entrée.

./hello_world

Vous pouvez utiliser le chemin relatif ou absolu. Lorsque vous utilisez le chemin relatif, utilisez toujours ./ au début de votre commande : Cela indique au terminal de chercher dans le dossier actuel (représenté par '.'), plutôt que dans les répertoires définis dans la variable d’environnement PATH.

Utiliser des commentaires pour annoter votre script

Tout ce qui suit un # sur une seule ligne dans un script Bash est considéré comme un commentaire. Cela peut être utile pour expliquer ce qu’une ligne complexe fait ou donner un aperçu des grandes parties de votre script.

Par exemple:

#!/bin/bash

#
# This shell script prints "hello world".
#

echo "hello world" # This line prints "hello world".

Une introduction aux variables

Lors de l’écriture de scripts, il peut être utile de définir des variables. En Bash, vous le faites en tapant le nom de la variable et sa valeur, séparés par un signe égal : NOM_VARIABLE='VALEUR'.

Vous ne devez pas mettre d’espaces à côté du signe égal, sinon Bash penserait que vous voulez exécuter un processus à la place.

Utilisez des guillemets simples pour entourer la valeur afin d’empêcher Bash de l’interpréter comme autre chose. En Bash, les variables n’ont pas de types, tout est essentiellement une chaîne de caractères. C’est aux programmes Bash d’analyser la chaîne en tant que type différent, comme un nombre.

Pour faire référence à la valeur d’une variable, utilisez le nom de la variable précédé du signe dollar : $NOM_VARIABLE.

Pour essayer cela en pratique, vous pouvez modifier votre script de cette manière :

#!/bin/bash
HELLO="hello variable world"
echo $HELLO # should print "hello variable world"

Réception des arguments

Les mots individuels que vous écrivez lors de la saisie d’une commande sont appelés arguments. Dans notre exemple chmod u+x 'hello_world', chmod, u+x et 'hello_world' sont trois arguments différents. chmod est le nom de la commande tandis que u+x et hello_world sont appelés paramètres — des arguments qui fournissent des informations supplémentaires à la commande.

Dans votre script, vous pouvez accéder à ces arguments via des variables. Pour éviter les conflits avec les variables locales, ces variables sont nommées en utilisant des nombres — $0 fait référence au nom de la commande, $1 est l’argument suivant, $2 celui d’après, et ainsi de suite.

Essayons ceci:

#!/bin/bash
HELLO="hello $1 world"
echo $HELLO

Maintenant, exécutez ce script avec ces paramètres:

./hello_world bash script

La sortie doit être hello bash world, avec le premier paramètre utilisé et le deuxième ignoré.

Si vous vouliez que bash script soit considéré comme un seul paramètre, vous devriez le mettre entre guillemets:

./hello_world 'bash script'

Utilisation de l’instruction if pour exécuter du code de manière conditionnelle

Une des choses essentielles que les programmeurs veulent faire dans un script est d’exécuter un morceau de code uniquement si une certaine condition est remplie. Bash a pour cela l’instruction if:

NUM=$RANDOM
if (( $NUM % 2 )) # if CONDITION
then
    echo "$NUM is odd"
fi # this is how you end an if statement

Astuce: À partir de maintenant, ces exemples sont supposés faire partie d’un script plus important et omettent le #!/bin/bash au début. N’oubliez pas de le mettre en première ligne de votre script, cependant!

Vous pouvez également utiliser else à l’intérieur d’une instruction if pour spécifier quoi faire si une condition n’est pas remplie, ou un elif (abrégé pour “else if“) pour spécifier une autre condition si la première condition n’a pas été remplie:

NUM=$RANDOM
if [ $NUM -eq 12 ]
then
    echo "$NUM is my favorite number"
elif (( $NUM % 2 ))
then
    echo "$NUM is odd"
else
    echo "$NUM is even"fi

‘fi’ est utilisé pour fermer l’instruction if.

Conseil : Si vous n’êtes pas sûr de comment écrire la condition elle-même, regardez la notation avec les balises test, crochets simples ([]), et double parenthèses ((())).

Répéter une série de commandes en utilisant une boucle for

Maintenant que nous avons vu comment exécuter du code de manière conditionnelle, regardons comment exécuter du code un certain nombre de fois tant qu’une condition est respectée.

La boucle for est parfaite pour une tâche de ce type — en particulier sa « syntaxe à trois expressions ». L’idée derrière est d’attribuer une variable spécifique à la boucle et de la modifier progressivement jusqu’à ce qu’une certaine condition soit respectée. Voici comment elle est structurée:

for (( ASSIGNMENT_EXPRESSION ; CONDITION_EXPRESSION ; UPDATE_EXPRESSION ))
do
    COMMANDS
done

Par exemple, si vous voulez qu’une boucle s’exécute 10 fois avec des valeurs pour i allant de 0 à 9, votre boucle for pourrait ressembler à ceci:

for (( i=0; i<10; i++ ))
do
    echo $i
done

Décortiquons cela:

• i=0 is the assignment expression here. It’s run only once before the loop is executed, which is why it’s useful for initializing a variable.
• i<10 is our condition expression. This expression is evaluated before each iteration of a loop. If it is equal to zero (which means the same as “true” in Bash), the next iteration is not run.
• i++ is our update expression. It’s run after each iteration of a loop.

Parcourir les éléments d’une liste

Outre la syntaxe à trois expressions, vous pouvez également utiliser le mot-clé in pour définir une boucle for. Cette syntaxe alternative est utilisée pour itérer à travers une série d’éléments.

L’exemple le plus basique consiste simplement à énumérer l’ensemble d’éléments à parcourir après le mot-clé in, séparés par des espaces. Par exemple :

for i in 0 1 2 3 4 5 6 7 8 9 # space-separated list items
do
    echo $i
done

Vous pouvez également itérer à travers les éléments produits par une commande:

for i in $(seq 0 1 9)

La notation $() est utilisée pour la substitution de commande en général — elle exécute une commande et sa sortie est utilisée comme entrée pour la commande parente qui l’entoure.

Si vous itérez à travers des entiers, il est préférable d’utiliser la syntaxe de plage intégrée de Bash, qui est plus efficace que la commande seq. Cependant, cette syntaxe n’est disponible que dans les versions Bash plus récentes:

• for i in {0..9}, disponible dans Bash 3.
• for i in {0..9..1}, disponible dans Bash 4, où le dernier nombre représente l’incrémentation.

Dans le même ordre d’idées, vous pouvez itérer à travers des chaînes également:

for s in 'item1' 'item2' 'item3'

En utilisant le globbing pour obtenir des fichiers correspondant à un motif

Un des cas d’utilisation les plus courants pour les boucles for discutés dans la section précédente est d’itérer à travers des fichiers individuels.

Pour cela, nous devons d’abord aborder les « expansions de glob », également appelées « expansions de gob ». C’est une fonctionnalité de Bash qui vous permet de spécifier des noms de fichiers en utilisant des motifs de correspondance. Il existe des caractères spéciaux appelés caractères génériques que vous utilisez pour définir ces motifs.

Avant d’approfondir cela, examinons quelques exemples spécifiques :

• echo * : Une commande qui renvoie les noms de tous les fichiers de votre répertoire actuel, sauf les fichiers cachés.
• echo *.txt : Une commande qui renvoie les noms de tous les fichiers non cachés avec une extension txt dans votre répertoire actuel.
• echo ???? : Une commande qui renvoie tous les noms de fichiers de quatre lettres dans votre répertoire actuel.

Les caractères génériques que nous avons utilisés ici sont * et ?. Il y a aussi un autre caractère générique que nous n’avons pas utilisé. Voici un aperçu :

• L’astérisque (*) représente un nombre quelconque de caractères (y compris 0) dans un nom de fichier ou de répertoire.
• Le point d’interrogation (?) représente un seul caractère dans un nom de fichier ou de répertoire.
• Le double astérisque (**) représente un nombre quelconque de caractères dans un chemin de fichier complet. Il s’agit d’une fonctionnalité dans Bash 4 et ultérieur et doit être activée en exécutant shopt -s globstar.
• Les crochets ([]) sont utilisés pour représenter un caractère dans un ensemble de symboles dans un nom de fichier ou de répertoire. Par exemple [st]ake trouverait des fichiers nommés sake ou take, mais pas stake.

Remarquez que tous les fichiers cachés (ceux dont le nom commence par un point .) sont ignorés lors de l’expansion du glob.

La notation des crochets permet une légère complexité supplémentaire, notamment :

• Les plages définies par la première et la dernière valeur — par exemple [1-8]
• Élimination de certains caractères en utilisant ! comme premier caractère à l’intérieur des crochets — par exemple [!3]

Pour traiter l’un de ces caractères spéciaux comme un caractère normal sans aucun sens, il suffit de mettre un antislash devant — par exemple \?.

Itérer à travers les fichiers en utilisant une boucle for

Maintenant que nous avons couvert les bases de l’expansion de glob, voyons comment l’utiliser pour itérer à travers les fichiers.

Nous pouvons simplement utiliser les opérateurs glob dans la boucle for elle-même. Voici un exemple simple d’une boucle imprimant le nom de chaque fichier dans le répertoire actuel:

for f in *
do
    echo $f
done

Pour imprimer les noms de chaque fichier dans le répertoire actuel ainsi que ses sous-répertoires, vérifiez que vous exécutez Bash 4.0 ou plus en exécutant bash --version, et ensuite vous pouvez exécuter la commande suivante:

shopt -s globstar # enables using **
for f in **
do
    echo $f
done

Astuce: Si vous exécutez une version plus ancienne de Bash, vous ne pourrez pas utiliser le globbing avec une boucle for pour cela. Votre meilleure option serait la commande find, mais nous n’aborderons pas cela dans cet article.

Ce ne sont bien sûr que quelques-uns des boucles les plus simples que vous pouvez exécuter, mais il y a beaucoup plus que vous pouvez faire. Par exemple, pour renommer tous les fichiers JPG dans un dossier afin de leur donner un nom de fichier séquentiel cohérent, vous pourriez exécuter :

i=1
for f in *.jpg
do
    mv -i -- "$f" "image_$i.jpg"
    let i=i+1
done

Exécution de code tant qu’une condition est vraie

La boucle for n’est pas le seul type de boucle que nous pouvons utiliser en Bash – nous avons également la while : Ce type de boucle s’exécute tant qu’une condition spécifique est vraie.

La syntaxe est similaire à la syntaxe de la boucle for:

while CONDITION
do
    COMMANDS
done

Pour un exemple pratique, voici comment vous pourriez lire un fichier ligne par ligne (sauf les espaces vides en début ou en fin de ligne) jusqu’à ce que vous atteigniez la fin du fichier :

while read -r line
do
    echo "$line"
done < FILENAME # Replace FILENAME with the path to a text file you'd like to read

Vous pouvez également remplacer une boucle for par une boucle while, par exemple pour itérer de 0 à 9 :

i=0
while [ $i -lt 10 ]
do
    echo $i
    let i=i+1
done

Et vous pourriez également théoriquement exécuter une boucle indéfiniment. Voici un exemple de commande :

while true
do
    echo "running forever"
done

Astuce : Pour arrêter le script, appuyez simplement sur Ctrl+C.

Alors que cette boucle infinie peut sembler inutile à première vue, elle peut en réalité être très utile, surtout lorsqu’elle est combinée avec l’instruction break.

Sortir d’une boucle

L’instruction break est utilisée pour sortir d’une boucle.

Cela vous permet d’exécuter une boucle infinie et d’en sortir lorsque des conditions de sortie se présentent.

Pour examiner un exemple simple, nous pouvons reproduire notre boucle allant de 0 à 9 avec une boucle infinie comme ceci :

i=0while true
do
    if [ $i -eq 10 ]
    then
        break
    fi
    echo $i
    let i=i+1
done

Si vous avez plusieurs boucles while imbriquées, vous pouvez ajouter un nombre après l’instruction break pour indiquer à quel niveau de boucle sortir : break 1 est le même que break et sortira de la boucle la plus proche, break 2 sortira de la boucle d’un niveau au-dessus, etc.

Jetons un coup d’œil à un exemple rapide, cette fois-ci avec des boucles for, en itérant à travers chaque combinaison de mots de quatre lettres jusqu’à atteindre le mot « bash » :

for l4 in {a..z}
do
    for l3 in {a..z}
    do
        for l2 in {a..z}
        do
            for l1 in {a..z}
            do
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

A related keyword that’s also worth a mention is continue, which skips to the next iteration of the loop. Just like break, it also takes an optional numeric argument that corresponds to the loop level.

Voici un exemple stupide où nous sautons tous les mots avec des Es dans notre liste de mots de quatre lettres raccourcis :

for l4 in {a..z}
do
    if [ $l4 = "e" ]
    then
        continue
    fi
    for l3 in {a..z}
    do
        if [ $l3 = "e" ]
        then
            continue
        fi
        for l2 in {a..z}
        do
            if [ $l2 = "e" ]
            then
                continue
            fi
            for l1 in {a..z}
            do
                if [ $l1 = "e" ]
                then
                    continue
                fi
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

Nous pourrions également exécuter toutes ces instructions continue au niveau de la boucle le plus profond :

for l4 in {a..z}
do
    for l3 in {a..z}
    do
        for l2 in {a..z}
        do
            for l1 in {a..z}
            do
                if [ $l4 = "e" ]
                then
                    continue 4
                fi
                if [ $l3 = "e" ]
                then
                    continue 3
                fi
                if [ $l2 = "e" ]
                then
                    continue 2
                fi
                if [ $l1 = "e" ]
                then
                    continue
                fi
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

Comment obtenir une entrée utilisateur dans un script shell

Parfois, vous voulez que l’utilisateur interagisse directement avec votre script plutôt que d’utiliser uniquement les arguments du script initial. C’est là que la commande read entre en jeu.

Pour obtenir une entrée utilisateur et la sauvegarder dans une variable appelée NAME, vous utilisez cette commande :

read NAME 

C’est la forme la plus simple de la commande, composée uniquement du nom de la commande et de la variable dans laquelle vous souhaitez sauvegarder l’entrée.

Plus fréquemment cependant, vous voudrez demander à l’utilisateur de manière à ce qu’il sache quoi taper. Vous le faites avec l’argument -p, après quoi vous écrivez votre invite préférée.

Voici comment vous pourriez demander un nom, en l’attribuant à une variable appelée NOM:

read -p "Your name: " NAME
echo "Your name is $NAME." # this line is here just to show that the name has been saved to the NAME variable

Impression des caractères spéciaux dans une chaîne

Il y a plusieurs caractères en Bash pour lesquels il faut être prudent lors de leur utilisation. Par exemple, les espaces dans les noms de fichiers, les guillemets dans les chaînes de caractères, ou les barres obliques inverses presque partout.

Pour indiquer à Bash d’ignorer leur signification spéciale dans certains endroits, vous pouvez soit les « échapper » soit les envelopper dans une citation littérale.

«Échapper» à un caractère spécial signifie indiquer à Bash de le traiter simplement comme un caractère sans aucune signification spéciale. Pour ce faire, écrivez une barre oblique inversée devant ce caractère.

Disons que nous avons un fichier nommé img \ 01 *DRAFT*, par exemple. En Bash, nous pourrions y faire référence de cette manière:

img\ \\\ 01\ \*DRAFT\*

Voici une liste non exhaustive des caractères spéciaux en Bash:

• Espace blanc: espace, tabulation, ligne vide
• Guillemets: ”, “”
• Parenthèses, accolades et crochets: ( ), { }, [ ]
• Tuyaux et redirections: |, <, >
• Métacaractères: *, ?
• Divers: !, #, ;, =, &, ~, `
• Le caractère d’échappement lui-même: \

Si vous débutez avec Bash, il peut être fastidieux de se souvenir des caractères ayant une signification spéciale. Par conséquent, dans de nombreuses situations, il peut être plus facile d’utiliser une citation littérale: Entourez simplement le texte contenant des caractères spéciaux de guillemets simples, et tous les caractères spéciaux à l’intérieur de ces guillemets seront ignorés.

Voici comment cela se présenterait pour notre exemple : 

'img \ 01 *DRAFT*'

Et si vous voulez utiliser un caractère spécial, mais échapper aux autres ? Vous pourriez échapper à chaque autre caractère en utilisant un antislash, mais vous pouvez aussi vous épargner la peine et entourer tout sauf ce caractère spécial de guillemets littéraux.

Par exemple, disons que vous avez plusieurs fichiers nommés img \ 01 *v1 DRAFT*, img \ 01 *v2 DRAFT*, img \ 01 *ROUGH DRAFT*, etc., et que vous voulez utiliser une expansion de glob pour faire correspondre tous ces noms de fichiers. Voici ce que vous pourriez écrire : 

'img \ 01 *'*' DRAFT*'

Si ce que vous avez besoin d’écrire contient une apostrophe – par exemple img \ 01 *’FINAL’* – vous pouvez utiliser une stratégie similaire, en combinant des chaînes littérales et des échappements : 

'img \ 01 '\''FINAL'\'

Comment concaténer des chaînes en Bash

Disons que vous avez deux variables de chaîne ou plus – un prénom et un nom de famille, par exemple :

FIRST_NAME="Johnny"LAST_NAME="Appleseed"

Pour combiner ces variables en une seule chaîne, peut-être avec un délimiteur personnalisé, créez simplement une nouvelle chaîne composée de ces deux variables :

NAME="$LAST_NAME"', '"$FIRST_NAME"

Vous pouvez également utiliser des guillemets doubles avec des variables intégrées pour cela, en utilisant des accolades pour séparer les noms des variables du texte environnant :

NAME="${LAST_NAME}, ${FIRST_NAME}"

Bash permet également l’utilisation de l’opérateur += pour ajouter du texte à une chaîne, comme ceci :

NAME='Appleseed'NAME+=', 'NAME+='Johnny'

Exécuter des commandes à l’intérieur d’une chaîne

Bash vous permet également d’utiliser la sortie d’une commande à l’intérieur d’une chaîne, également appelée substitution de commande. Il suffit d’entourer votre commande avec $(). Par exemple, pour afficher un horodatage actuel, vous pouvez exécuter :

echo "Current timestamp: $(date)"

Vous vous souvenez peut-être aussi de cette syntaxe d’une précédente boucle for, lorsque nous avons itéré à travers une séquence d’entiers de 0 à 9 :

for i in $(seq 0 1 9)
do
    echo $i
done

La commande substituée est exécutée dans un sous-shell. Cela signifie que, par exemple, toutes les variables créées pendant la commande n’affecteront pas l’environnement dans lequel vous exécutez votre script.

Définition et retour des codes de sortie dans un script shell

Pour un script plus complexe, il est coutumier de le faire retourner un code de sortie — un nombre entre 0 et 255 qui indique aux utilisateurs si le script s’est exécuté correctement ou a rencontré une erreur.

Quant aux numéros à utiliser, le manuel officiel de Bash spécifie ceux-ci :

• 0 : Programme exécuté avec succès.
• 2 : Programme utilisé incorrectement (par exemple en raison d’arguments invalides ou manquants).
• 1 et 3-124 : Erreurs définies par l’utilisateur.
• 126 : Commande non exécutable.
• 127 : Commande non trouvée.
• 125 et 128-255 : Statuts d’erreur utilisés par le shell. Si un processus est arrêté par un signal N, le statut de sortie est 128 + N.

Comme vous pouvez le voir, tous les chiffres sauf 0 indiquent un certain type d’erreur. Le code de sortie 1 est couramment utilisé pour les erreurs générales. Dans la plupart des cas, vous n’aurez pas besoin d’utiliser de code de sortie supérieur à 2.

Pour renvoyer un code de sortie à partir de votre script, il suffit d’utiliser la commande exit. Par exemple, pour sortir avec un code 2, vous écririez exit 2.

Si vous n’utilisez pas la commande exit dans votre script ou utilisez la commande sans spécifier de code, le statut de sortie de la dernière commande exécutée dans votre script sera renvoyé.

Pour obtenir le code de sortie de la dernière commande exécutée dans votre shell, utilisez la variable $? : echo $?.

Comment appeler une fonction

Lorsque vous rédigez un script plus long ou un script avec des morceaux de code répétitifs, vous voudrez peut-être séparer certains codes en fonctions. Il existe deux formats que vous pouvez utiliser pour définir des fonctions : Dans les deux cas, tout le code de la fonction est contenu à l’intérieur d’accolades et seule la déclaration de la fonction diffère.

Le format plus compact utilise des parenthèses qui suivent le nom de la fonction pour déclarer une fonction :

function_name () {
    echo "This is where your function code goes"
}

L’autre format utilise le mot-clé function devant un nom de fonction :

function function_name {
    echo "This is where your function code goes"
}

Les fonctions doivent être déclarées avant d’être appelées dans votre script. Vous appelez une fonction de la même manière que vous exécutez une commande ordinaire, en utilisant le nom de la fonction comme commande:

function_name

Transmettre des données à une fonction en utilisant des variables

En Bash, les fonctions ne peuvent pas prendre d’arguments. Pour envoyer des informations à une fonction, vous devez utiliser des variables globales dans votre script.

Par exemple:

is_your_name_defined () {
    if [ -z "$YOUR_NAME" ]
    then
        echo "It doesn't seem like I have your name."
    else
        echo "Is this your name: ${YOUR_NAME}?"
    fi
}
read -p "Your name: " YOUR_NAME

is_your_name_defined

Contrairement à ce à quoi vous pourriez être habitué dans d’autres langages, les variables que vous définissez à l’intérieur de votre fonction sont globales et visibles par le code en dehors de votre script. Pour définir une variable localisée uniquement à votre fonction (c’est-à-dire inaccessible à tout code extérieur à celle-ci), utilisez le mot-clé local : par ex. local i=0.

Si vous souhaitez renvoyer des valeurs à partir d’une fonction, vous devez également utiliser des variables globales. En Bash, les fonctions ne peuvent renvoyer que des codes de sortie, en utilisant le mot-clé return. Regardons un exemple:

is_your_name_defined () {
    if [ -z "$YOUR_NAME" ]
    then
        MESSAGE="It doesn't seem like I have your name."
    else
        MESSAGE="Is this your name: ${YOUR_NAME}?"
    fi
}
read -p "Your name: " YOUR_NAME

is_your_name_defined

echo $MESSAGE

Résumé

Le scripting Bash vous permet d’accomplir beaucoup de choses sur un système d’exploitation basé sur UNIX. Cet article a abordé certains des concepts de base du scripting Bash, y compris la création et l’exécution de scripts, le travail avec les chaînes de caractères et l’utilisation de boucles dans votre code. Espérons que cela servira de bon point de départ à votre parcours dans l’écriture de scripts Bash puissants qui répondent à vos besoins.

Il y a encore beaucoup à apprendre sur Bash, y compris certaines des commandes les plus utiles, la navigation dans le système de fichiers, etc. Faites-nous savoir dans les commentaires quels sujets nous devrions aborder ensuite.

Article Connexe:

• Comment utiliser Chmod Recursive pour modifier les autorisations de fichiers sur Linux et macOS