Logique conditionnelle avec if else

Introduction

Imaginez que vous conduisez une voiture avec un GPS. Le GPS ne vous donne pas une simple liste d’instructions : il réagit à la route. S’il y a des embouteillages, il vous propose un autre itinéraire. Si vous manquez une sortie, il recalcule votre trajet.

En scripting, nous appelons cela la logique conditionnelle. Sans elle, un script n’est qu’une liste aveugle de commandes. Avec elle, le script peut examiner la situation actuelle et choisir l’action à effectuer.

C’est l’une des bases de l’automatisation fiable. Les systèmes réels ne se trouvent pas toujours dans le même état : les bons scripts doivent donc réagir au lieu de partir du principe que tout est toujours identique.

Dans ce lab, vous allez ajouter un « cerveau » à vos scripts avec if et else.

Vous apprendrez à votre script à :

Vérifier la réalité : vérifier qu’un fichier existe réellement avant d’essayer de l’ouvrir ;
Prendre des décisions : effectuer une action si la réponse est « Oui » et une autre si la réponse est « Non » ;
Vérifier l’identité : vérifier que l’utilisateur dispose des autorisations nécessaires (Root) pour exécuter le script.

Vérifier qu’un fichier existe

Un bon script agit comme un conducteur prudent : il regarde avant d’agir. Sous Linux, l’une des vérifications les plus courantes consiste à demander : « Ce fichier existe-t-il ? »

Nous utilisons l’option -f (test de fichier) dans un bloc if. Considérez if comme un agent de sécurité : il ne laisse le code situé à l’intérieur s’exécuter que si la condition est remplie.

Voici votre premier exemple concret de script qui prend une décision en fonction de l’état du système. C’est une étape importante : vous passez de « exécuter les commandes dans l’ordre » à « examiner l’environnement, puis choisir une action ». Une grande partie des scripts d’administration repose exactement sur ce modèle.

Commencez par accéder au dossier de votre projet :

cd ~/project

Créez un script nommé check_file.sh :

nano check_file.sh

Saisissez le code suivant. Nous allons vérifier si data.txt existe.

#!/bin/bash

FILE="data.txt"

if [ -f "$FILE" ]; then
  echo "$FILE exists."
fi

Décodage de la logique :

if [ ... ]; then : c’est le garde-fou. Il pose une question entre crochets.
-f "$FILE" : c’est la question : « data.txt est-il un fichier réel ? »
echo ... : c’est l’action. Elle ne s’exécute que si le garde-fou répond « Oui ».
fi : signifie « fin de if ». Cela indique à Linux que la section conditionnelle est terminée.

La forme entre crochets [ ... ] est la manière courante dont Bash exécute un test. Ici, elle vérifie une propriété du fichier. Linux et Bash fournissent de nombreux opérateurs de test de ce type. Leur apprentissage permet aux scripts de raisonner sur les fichiers, les chaînes de caractères, les nombres et les autorisations.

Enregistrez le fichier (Ctrl+O), puis quittez (Ctrl+X).

Rendez le script exécutable :

chmod +x check_file.sh

Test 1 : le fichier invisible

Exécutez maintenant le script :

./check_file.sh

Rien ne se passe. Le terminal reste silencieux.

Pourquoi ? Parce que data.txt n’existe pas. Le garde-fou a répondu « Non », donc la commande echo a été entièrement ignorée.

Test 2 : le fichier visible

Créez maintenant le fichier :

touch data.txt

Exécutez à nouveau le script :

./check_file.sh

Cette fois, le garde-fou répond « Oui » et vous voyez :

data.txt exists.

Ajouter un bloc else

Le silence est déroutant. Lorsqu’un script ne fait rien, vous ne savez pas s’il a échoué ou s’il s’est simplement terminé. Nous avons besoin d’un plan B.

En logique, il s’agit d’une « bifurcation ».

Chemin A (if) : le fichier existe. Très bien.
Chemin B (else) : le fichier est absent. Corrigeons la situation.

Modifions le script afin qu’il crée automatiquement le fichier manquant.

Commencez par supprimer le fichier de test pour effectuer une vraie vérification :

rm data.txt

Ouvrez votre script :

nano check_file.sh

Ajoutez le bloc else comme indiqué ci-dessous :

#!/bin/bash

FILE="data.txt"

if [ -f "$FILE" ]; then
  echo "$FILE exists."
else
  echo "$FILE does not exist. Creating it now..."
  touch "$FILE"
fi

La logique :

Si if est vrai → exécuter la première partie.

Si if est faux → exécuter la partie else.

Ce type de script est souvent plus proche des opérations réelles qu’un script qui se contente d’afficher des informations. Au lieu de signaler simplement qu’un élément manque, il corrige la situation. C’est pourquoi la logique conditionnelle constitue la base de nombreux scripts d’installation et de maintenance.

Enregistrez le fichier, puis quittez l’éditeur.

Tester la logique

Exécutez le script. data.txt est absent : le script doit donc suivre le chemin B.

./check_file.sh

Sortie attendue :

data.txt does not exist. Creating it now...

Exécutez-le immédiatement une deuxième fois. data.txt existe maintenant : le script doit donc suivre le chemin A.

./check_file.sh

Sortie attendue :

data.txt exists.

Votre script est maintenant « idempotent ». Ce terme signifie que vous pouvez l’exécuter 100 fois : il garantira toujours le résultat attendu — l’existence du fichier — sans provoquer d’erreur.

Ce terme apparaît souvent dans le domaine du DevOps. Une action idempotente peut être répétée sans danger, car l’état final compte davantage que le nombre d’exécutions de la commande. L’automatisation devient ainsi plus fiable, en particulier lorsque des tâches sont relancées.

Vérifier les autorisations root

Certaines portes de Linux sont verrouillées. Seul le superutilisateur (Root) possède la clé. Si vous essayez d’exécuter un script de maintenance système avec un utilisateur normal, l’opération échouera avec le message « Permission Denied ».

Un script bien conçu vérifie votre identité avant d’essayer d’ouvrir la porte.

Sous Linux, chaque utilisateur possède un numéro (UID).

Root a toujours l’UID 0.
Les utilisateurs normaux ont généralement un UID supérieur ou égal à 1000.

Écrivons un script qui vérifie votre identifiant.

Créez check_root.sh :

nano check_root.sh

Saisissez le code suivant :

#!/bin/bash

if [ "$UID" -eq 0 ]; then
  echo "You are running this script as root."
else
  echo "You are running this script as a regular user."
fi

Décodage :

$UID : la variable qui contient votre numéro d’identification actuel ;
-eq : signifie « égal ». Nous utilisons -eq pour les nombres et = pour les mots.

Voici un autre exemple de syntaxe de test. Pour comparer des nombres entre [ ... ], Bash utilise des opérateurs tels que -eq, -ne, -lt et -gt. Ils sont différents des opérateurs de comparaison de chaînes, car le shell doit savoir s’il compare des mots ou des valeurs numériques.

Enregistrez le fichier, puis quittez l’éditeur. Rendez ensuite le script exécutable :

chmod +x check_root.sh

Le test

Vous êtes connecté en tant que labex : vous êtes donc un utilisateur normal.

Exécutez le script normalement :

./check_root.sh

Le script détecte votre identifiant différent de zéro et affiche :

You are running this script as a regular user.

Utilisons maintenant temporairement les privilèges du superutilisateur avec sudo :

sudo ./check_root.sh

sudo remplace votre identifiant par 0 pour cette seule commande. Le script le détecte et affiche :

You are running this script as root.

C’est ainsi que fonctionnent les scripts d’installation professionnels : ils refusent de s’exécuter si vous n’êtes pas root.

L’objectif n’est pas d’exiger les privilèges root pour toutes les opérations, mais de vérifier les privilèges avant de tenter une action protégée. Un script bien écrit s’arrête rapidement en fournissant une explication claire, au lieu de s’exécuter à moitié puis de provoquer des erreurs d’autorisation difficiles à comprendre.

Résumé

Vous venez de donner un cerveau à vos scripts !

Dans ce lab, vous avez appris :

Le garde-fou (if) : poser des questions telles que « Ce fichier existe-t-il ? » avec -f ;
La bifurcation (else) : prévoir une solution de remplacement lorsque la réponse est « Non » ;
La vérification de l’identité : utiliser la comparaison numérique (-eq) pour vérifier les autorisations de l’utilisateur.

Vos scripts ne sont désormais plus de simples listes de commandes : ce sont des programmes intelligents capables de s’adapter à leur environnement.