Unix / Linux - Shell Basic Operators

Bonjour, futurs programmeurs ! Je suis ravi de vous guider à travers le monde fascinant des opérateurs du shell Unix/Linux. En tant que quelqu'un qui enseigne l'informatique depuis plus d'une décennie, je peux vous assurer que maîtriser ces opérateurs sera un véritable jeu-changer dans votre parcours de programmation. Plongeons dedans !

Opérateurs arithmétiques

Les opérateurs arithmétiques sont les briques de base des opérations mathématiques dans les scripts shell. Ils nous permettent d'effectuer des calculs de base dans nos scripts.

Voici un tableau des opérateurs arithmétiques les plus courants :

Opérateur	Description	Exemple
+	Addition	expr $a + $b
-	Soustraction	expr $a - $b
*	Multiplication	expr $a \* $b
/	Division	expr $a / $b
%	Modulo	expr $a % $b
=	Affectation	a=$b

Voici un exemple pratique :

#!/bin/bash
a=10
b=5

echo "Addition: `expr $a + $b`"
echo "Soustraction: `expr $a - $b`"
echo "Multiplication: `expr $a \* $b`"
echo "Division: `expr $a / $b`"
echo "Modulo: `expr $a % $b`"

Dans ce script, nous utilisons la commande expr pour effectuer des opérations arithmétiques. Les backticks () sont utilisés pour exécuter la commandeexpr` et substituer sa sortie.

Lorsque vous exécutez ce script, vous verrez :

Addition: 15
Soustraction: 5
Multiplication: 50
Division: 2
Modulo: 0

Souvenez-vous, dans les scripts shell, les espaces sont cruciaux. expr$a+$b ne fonctionnera pas, mais expr $a + $b le fera. C'est comme donner de l'espace à vos variables pour qu'elles puissent respirer !

Opérateurs relationnels

Les opérateurs relationnels sont utilisés pour comparer des valeurs. Ils sont essentiels pour créer des conditions dans vos scripts.

Voici un tableau des opérateurs relationnels :

Opérateur	Description	Exemple
-eq	Égal à	[ $a -eq $b ]
-ne	Différent de	[ $a -ne $b ]
-gt	Supérieur à	[ $a -gt $b ]
-lt	Inférieur à	[ $a -lt $b ]
-ge	Supérieur ou égal à	[ $a -ge $b ]
-le	Inférieur ou égal à	[ $a -le $b ]

Voyons ces opérateurs en action :

#!/bin/bash
a=10
b=20

if [ $a -eq $b ]
then
echo "$a est égal à $b"
elif [ $a -gt $b ]
then
echo "$a est supérieur à $b"
else
echo "$a est inférieur à $b"
fi

Ce script compare a et b en utilisant des opérateurs relationnels. Lorsque vous l'exécutez, vous verrez :

10 est inférieur à 20

Astuce pro : Pensez à ces opérateurs comme posant des questions. "-eq" est comme demander "Sont-ils égaux ?", "-gt" demande "Est-ce supérieur à celà ?". Il est utile de verbaliser ces comparaisons lorsque vous écrivez vos scripts.

Opérateurs booléens

Les opérateurs booléens nous permettent de combiner plusieurs conditions. Ils sont comme la colle logique de vos scripts.

Voici un tableau des opérateurs booléens :

Opérateur	Description	Exemple
!	NON	[ ! false ]
-o	OU	[ $a -lt 20 -o $b -gt 100 ]
-a	ET	[ $a -lt 20 -a $b -gt 100 ]

Voyons comment les utiliser dans un script :

#!/bin/bash
a=10
b=20

if [ $a -lt 20 -a $b -gt 15 ]
then
echo "Les deux conditions sont vraies"
else
echo "Au moins une condition est fausse"
fi

Lorsque vous exécutez ce script, vous verrez :

Les deux conditions sont vraies

J'aime penser aux opérateurs booléens comme des outils de prise de décision. Ils aident votre script à faire des choix basés sur plusieurs facteurs, tout comme nous le faisons dans la vie réelle !

Opérateurs de chaîne

Les opérateurs de chaîne sont utilisés pour comparer et manipuler des chaînes de caractères. Ils sont incroyablement utiles lors de la manipulation de données textuelles.

Voici un tableau des opérateurs de chaîne :

Opérateur	Description	Exemple
=	Égal à	[ $a = $b ]
!=	Différent de	[ $a != $b ]
-z	Chaîne nulle	[ -z $a ]
-n	Chaîne non nulle	[ -n $a ]
str	Chaîne non vide	[ $a ]

Voyons ces opérateurs en action :

#!/bin/bash
a="Hello"
b="World"

if [ $a = $b ]
then
echo "Les chaînes sont égales"
elif [ -z $a ]
then
echo "La chaîne a est vide"
elif [ -n $b ]
then
echo "La chaîne b n'est pas vide"
else
echo "Aucune des conditions ci-dessus n'est vraie"
fi

Lorsque vous exécutez ce script, vous obtiendrez :

La chaîne b n'est pas vide

Les opérateurs de chaîne sont comme les règles de grammaire du scripting shell. Ils vous aident à faire sens du texte que votre script manipule.

Opérateurs de test de fichier

Les opérateurs de test de fichier sont utilisés pour tester différentes conditions de fichier. Ils sont essentiels lorsque votre script doit interagir avec des fichiers et des répertoires.

Voici un tableau de certains opérateurs de test de fichier courants :

Opérateur	Description	Exemple
-d file	Répertoire existe	[ -d $file ]
-f file	Fichier existe et est un fichier régulier	[ -f $file ]
-r file	Fichier est lisible	[ -r $file ]
-w file	Fichier est modifiable	[ -w $file ]
-x file	Fichier est exécutable	[ -x $file ]
-s file	Fichier n'a pas une taille nulle	[ -s $file ]

Voyons comment les utiliser dans un script :

#!/bin/bash
file="/etc/passwd"

if [ -f $file ]
then
echo "Le fichier existe"
if [ -r $file ]
then
echo "Le fichier est lisible"
fi
if [ -w $file ]
then
echo "Le fichier est modifiable"
fi
if [ -x $file ]
then
echo "Le fichier est exécutable"
fi
else
echo "Le fichier n'existe pas"
fi

Lorsque vous exécutez ce script, vous pourriez voir quelque chose comme :

Le fichier existe
Le fichier est lisible

Les opérateurs de test de fichier sont comme les outils de détective de votre script. Ils aident votre script à comprendre ce qu'il peut ou ne peut pas faire avec différents fichiers.

Opérateurs du Shell C

Le Shell C (csh) a son propre ensemble d'opérateurs qui diffèrent légèrement de ceux du Shell Bourne. Voici quelques exemples :

#!/bin/csh
set a = 10
set b = 20

if ($a == $b) then
echo "a est égal à b"
else if ($a != $b) then
echo "a n'est pas égal à b"
endif

if ($a > $b) then
echo "a est supérieur à b"
else if ($a < $b) then
echo "a est inférieur à b"
endif

Dans le Shell C, nous utilisons == pour l'égalité et != pour l'inégalité. Nous pouvons également utiliser directement > et < pour les comparaisons.

Opérateurs du Shell Korn

Le Shell Korn (ksh) combine des fonctionnalités du Shell Bourne et du Shell C. Voici un exemple :

#!/bin/ksh
a=10
b=20

if ((a == b))
then
print "a est égal à b"
elif ((a != b))
then
print "a n'est pas égal à b"
fi

if ((a > b))
then
print "a est supérieur à b"
elif ((a < b))
then
print "a est inférieur à b"
fi

Dans le Shell Korn, nous pouvons utiliser (( et )) pour les opérations arithmétiques et les comparaisons, ce qui rend la syntaxe plus propre et intuitive.

Souvenez-vous, la pratique rend parfait ! N'ayez pas peur d'expérimenter avec ces opérateurs dans vos propres scripts. Chaque fois que vous les utilisez, vous deviendrez plus à l'aise et compétent. Bon scripting !

Credits: Image by storyset