Opérations logiques Linux

Introduction

Bienvenue dans le laboratoire sur les opérations logiques en Linux. Dans ce laboratoire, vous allez apprendre les opérations logiques en Linux, qui sont des outils essentiels pour contrôler le flux d'exécution des commandes et prendre des décisions dans les scripts.

Les opérations logiques vous permettent de combiner des commandes et des conditions, vous permettant ainsi de créer des scripts plus sophistiqués capables de répondre à différentes situations. À la fin de ce laboratoire, vous comprendrez comment utiliser les opérateurs logiques pour contrôler l'exécution des commandes et vérifier les attributs des fichiers en Linux.

Comprendre les opérations logiques de base en Linux

Le shell Linux propose plusieurs méthodes pour combiner des commandes et des conditions à l'aide d'opérateurs logiques. Dans cette étape, vous allez apprendre les opérateurs logiques les plus couramment utilisés : && (ET) et || (OU).

Tout d'abord, naviguons jusqu'au répertoire de notre projet :

cd ~/project

Commençons par créer quelques fichiers de test que nous utiliserons tout au long de ce laboratoire :

touch treasure_map.txt shield.txt kings_gauntlet.txt

Maintenant, créons un script pour démontrer les opérations logiques de base. Nous allons utiliser l'éditeur de texte nano pour créer un fichier appelé logic_basics.sh :

nano logic_basics.sh

Dans ce script, nous allons utiliser des opérateurs logiques pour vérifier si deux fichiers existent. Tapez ou collez le code suivant dans l'éditeur :

#!/bin/bash

## Ce script démontre les opérateurs logiques ET (&&) et OU (||)
## Il vérifie si deux fichiers spécifiques existent dans le répertoire actuel

if [[ -f "treasure_map.txt" ]] && [[ -f "shield.txt" ]]; then
  echo "Both files exist. Proceed with the mission."
else
  echo "One or both files are missing. Abort the mission!"
fi

L'opérateur && signifie "ET" - les deux conditions doivent être vraies pour que la condition globale soit vraie. Le test -f vérifie si un fichier existe et s'il s'agit d'un fichier ordinaire (pas d'un répertoire ou d'un autre type de fichier spécial).

Pour enregistrer le fichier dans nano, appuyez sur Ctrl+X, puis appuyez sur Y pour confirmer l'enregistrement, et appuyez sur Enter pour confirmer le nom du fichier.

Maintenant, rendons le script exécutable et exécutons-le :

chmod +x logic_basics.sh
./logic_basics.sh

Vous devriez voir la sortie suivante :

Both files exist. Proceed with the mission.

Essayons un autre exemple pour mieux comprendre les opérateurs logiques. Créez un nouveau script appelé logical_or.sh :

nano logical_or.sh

Ajoutez le contenu suivant :

#!/bin/bash

## Ce script démontre l'opérateur logique OU (||)
## Il vérifie si au moins l'un des deux fichiers existe

if [[ -f "treasure_map.txt" ]] || [[ -f "nonexistent_file.txt" ]]; then
  echo "At least one file exists."
else
  echo "Neither file exists."
fi

L'opérateur || signifie "OU" - si l'une des conditions est vraie, la condition globale est vraie.

Enregistrez le fichier (Ctrl+X, Y, Enter), rendez-le exécutable et exécutez-le :

chmod +x logical_or.sh
./logical_or.sh

Sortie :

At least one file exists.

Cela démontre que même si "nonexistent_file.txt" n'existe pas, la condition est toujours vraie car "treasure_map.txt" existe.

Opérations logiques avec les permissions de fichiers

En Linux, les permissions de fichiers contrôlent qui peut lire, écrire ou exécuter des fichiers. Dans cette étape, vous allez apprendre à utiliser les opérations logiques pour vérifier les permissions de fichiers.

Tout d'abord, créons un script appelé permission_check.sh :

nano permission_check.sh

Ajoutez le contenu suivant au script :

#!/bin/bash

## Ce script vérifie les permissions de lecture et d'écriture sur un fichier
## en utilisant des opérateurs logiques

filename="kings_gauntlet.txt"

if [[ -r "$filename" ]] && [[ -w "$filename" ]]; then
  echo "You have read and write permissions on $filename."
elif [[ -r "$filename" ]] || [[ -w "$filename" ]]; then
  echo "You have limited permissions on $filename."
else
  echo "You do not have permissions on $filename."
fi

Dans ce script :

-r teste si un fichier est lisible par l'utilisateur actuel
-w teste si un fichier est écrivable par l'utilisateur actuel
L'opérateur && exige que les deux conditions soient vraies
L'opérateur || exige qu'au moins une condition soit vraie

Enregistrez le fichier (Ctrl+X, Y, Enter) et rendez-le exécutable :

chmod +x permission_check.sh

Maintenant, modifions les permissions de notre fichier de test et voyons comment cela affecte la sortie de notre script.

Tout d'abord, définissons les permissions pour autoriser la lecture et l'écriture :

chmod 600 kings_gauntlet.txt
./permission_check.sh

Sortie :

You have read and write permissions on kings_gauntlet.txt.

Maintenant, changeons les permissions en lecture seule :

chmod 400 kings_gauntlet.txt
./permission_check.sh

Sortie :

You have limited permissions on kings_gauntlet.txt.

Enfin, supprimons toutes les permissions :

chmod 000 kings_gauntlet.txt
./permission_check.sh

Sortie :

You do not have permissions on kings_gauntlet.txt.

N'oubliez pas de restaurer des permissions raisonnables au fichier :

chmod 600 kings_gauntlet.txt

Chaînage de commandes avec des opérateurs logiques

Les opérateurs logiques en Linux ne sont pas seulement utilisés pour les instructions conditionnelles dans les scripts - ils peuvent également être utilisés directement dans la ligne de commande pour chaîner des commandes. Dans cette étape, vous allez apprendre à utiliser les opérateurs logiques pour le chaînage de commandes.

L'opérateur && vous permet d'exécuter une deuxième commande seulement si la première commande réussit (renvoie un statut de sortie égal à zéro). Cela est utile pour exécuter une séquence de commandes où chaque étape dépend du succès de l'étape précédente.

Essayons un exemple simple :

mkdir -p test_dir && echo "Directory created successfully"

La commande mkdir -p crée un répertoire (et les répertoires parents si nécessaire), et l'option -p évite une erreur si le répertoire existe déjà. La commande echo s'exécute seulement si la commande mkdir réussit.

Sortie :

Directory created successfully

Maintenant, essayons l'opérateur ||, qui exécute la deuxième commande seulement si la première commande échoue :

ls nonexistent_file.txt || echo "File not found"

Comme "nonexistent_file.txt" n'existe pas, la commande ls échoue, et la commande echo s'exécute.

Sortie :

ls: cannot access 'nonexistent_file.txt': No such file or directory
File not found

Vous pouvez également combiner plusieurs commandes en utilisant ces opérateurs. Créez un script appelé command_chain.sh :

nano command_chain.sh

Ajoutez le contenu suivant :

#!/bin/bash

## Ce script démontre le chaînage de commandes avec des opérateurs logiques

echo "Starting command chain..."

## Crée un répertoire et y accède seulement si la création réussit
mkdir -p logic_test && cd logic_test && echo "Changed to new directory"

## Crée un fichier et y écrit seulement si la création réussit
touch test_file.txt && echo "This is a test" > test_file.txt && echo "Created and wrote to file"

## Essaye de lire un fichier inexistant, ou affiche un message d'erreur
cat nonexistent.txt || echo "Failed to read file"

## Revient au répertoire d'origine
cd .. && echo "Returned to original directory"

echo "Command chain completed"

Enregistrez le fichier (Ctrl+X, Y, Enter), rendez-le exécutable et exécutez-le :

chmod +x command_chain.sh
./command_chain.sh

Sortie :

Starting command chain...
Changed to new directory
Created and wrote to file
cat: nonexistent.txt: No such file or directory
Failed to read file
Returned to original directory
Command chain completed

Ce script démontre comment les opérateurs logiques peuvent contrôler le flux d'exécution des commandes en fonction du succès ou de l'échec des commandes précédentes.

Opérateurs avancés de test de fichiers

Linux propose une variété d'opérateurs de test de fichiers qui peuvent être combinés avec des opérateurs logiques. Dans cette étape, vous allez apprendre à connaître certains des opérateurs de test de fichiers les plus utiles.

Créons un script qui démontre ces opérateurs :

nano file_tests.sh

Ajoutez le contenu suivant :

#!/bin/bash

## Ce script démontre divers opérateurs de test de fichiers en Linux

## Vérifie si un fichier existe (en tant que fichier, répertoire ou autre type)
file_to_check="treasure_map.txt"
directory_to_check="test_dir"

echo "--- Basic File Tests ---"
## -e vérifie si le fichier existe (n'importe quel type)
if [[ -e "$file_to_check" ]]; then
  echo "$file_to_check exists"
else
  echo "$file_to_check does not exist"
fi

## -f vérifie si c'est un fichier ordinaire (pas un répertoire ou un périphérique)
if [[ -f "$file_to_check" ]]; then
  echo "$file_to_check is a regular file"
fi

## -d vérifie si c'est un répertoire
if [[ -d "$directory_to_check" ]]; then
  echo "$directory_to_check is a directory"
else
  echo "$directory_to_check is not a directory"
fi

echo "--- File Size Tests ---"
## -s vérifie si le fichier n'est pas vide (a une taille supérieure à zéro)
if [[ -s "$file_to_check" ]]; then
  echo "$file_to_check is not empty"
else
  echo "$file_to_check is empty"
fi

echo "--- Permission Tests ---"
## -r, -w, -x vérifient les permissions de lecture, d'écriture et d'exécution
if [[ -r "$file_to_check" ]]; then
  echo "$file_to_check is readable"
fi

if [[ -w "$file_to_check" ]]; then
  echo "$file_to_check is writable"
fi

if [[ -x "$file_to_check" ]]; then
  echo "$file_to_check is executable"
else
  echo "$file_to_check is not executable"
fi

echo "--- Combining Tests with Logical Operators ---"
## Combinaison de tests avec ET (&&)
if [[ -f "$file_to_check" ]] && [[ -r "$file_to_check" ]]; then
  echo "$file_to_check is a readable file"
fi

## Combinaison de tests avec OU (||)
if [[ -f "$file_to_check" ]] || [[ -d "$file_to_check" ]]; then
  echo "$file_to_check is either a file or a directory"
fi

Enregistrez le fichier (Ctrl+X, Y, Enter), rendez-le exécutable et exécutez-le :

chmod +x file_tests.sh
./file_tests.sh

La sortie affichera les résultats de divers tests de fichiers sur nos fichiers et répertoires existants.

Pour rendre les tests plus intéressants, ajoutons du contenu à notre fichier treasure_map.txt et créons le répertoire que nous testons :

echo "This is a treasure map!" > treasure_map.txt
mkdir -p test_dir

Exécutons maintenant le script à nouveau :

./file_tests.sh

Vous devriez voir une sortie différente maintenant que le fichier a du contenu et que le répertoire existe.

Ce script démontre comment utiliser divers opérateurs de test de fichiers et les combiner avec des opérateurs logiques pour créer des vérifications de fichiers sophistiquées.

Résumé

Dans ce laboratoire, vous avez appris les opérations logiques en Linux et comment elles peuvent être utilisées pour contrôler le flux d'exécution des commandes et le comportement des scripts. Voici un résumé de ce que vous avez appris :

Vous avez appris les opérateurs logiques de base && (ET) et || (OU) et comment les utiliser dans les instructions conditionnelles.
Vous avez utilisé des opérateurs de test de fichiers tels que -f, -r, -w et -x pour vérifier l'existence et les permissions des fichiers.
Vous avez pratiqué le chaînage de commandes en utilisant des opérateurs logiques pour créer des séquences d'opérations qui dépendent du succès ou de l'échec des commandes précédentes.
Vous avez exploré divers opérateurs de test de fichiers et appris à les combiner avec des opérateurs logiques pour créer des conditions plus complexes.

Ces opérations logiques sont des outils fondamentaux dans l'utilisation des scripts et de la ligne de commande en Linux. Elles vous permettent de créer des scripts plus sophistiqués capables de gérer différentes situations en fonction de conditions et des résultats des commandes précédentes.

En maîtrisant les opérations logiques, vous avez acquis une compétence essentielle pour l'administration système, l'automatisation et la programmation de scripts en Linux, qui vous sera très utile dans votre parcours en tant qu'utilisateur ou administrateur Linux.