Programmation Système

(Script Shell) L3 IRT

Franck ADJEGAN
[Link]@[Link]
+22965464376

Janvier 2025
Ce que vous allez apprendre pendant
le cours
 • Qu’est-ce qu’un script ?
 • Les composants principaux d’un script.
 • Comment utiliser des variables.
 • De quelle manière peut-on effectuer des tests et des prises de
décision.
 • Comment donner des arguments à votre script.
 • Comment permettre à l’utilisateur de rentrer des données qui vont
pouvoir être utilisées par le script.
Qu’est ce qu’un script

 Une série de commandes définies dans un fichier pour l’automatisation

d’une tâche donnée
 Ces commandes sont exécutées les unes après les autres par un
interpréteur (le shell dans notre cas)
 Tout ce qui est réalisable en ligne de commande peut être inclus dans un
script
 Le scripting est une méthode pour l’automatisation de tâches
Cas d’ Utilisation

 maintenance quotidienne d’un système

 sauvegarde hebdomadaire de fichiers vers un serveur
 planification de tâches répétitives et/ou fastidieuses
 extraction de données utiles de fichiers volumineux
Comment Rendre un script
Exécutable
 Pour pouvoir exécuter un fichier de script, il faut définir dessus les droits de
manière à ce que celui-ci devienne exécutable .

 Utilisation de chmod (change mode)

Syntaxe :
chmod a+x nom_fichier

chmod a+x permet de rajouter le droit d’exécution à tous les utilisateurs pour le
fichier nom_fichier
 Exemple :
chmod a+x [Link]
Comment Rendre un script
Exécutable (2)
 Les catégories d’utilisateurs
u propriétaire (user)
g groupe (group)
o les autres (others)
a tous (all)

 Les permissions
r (4) : autorisation de lecture
w (2) : autorisation d'écriture
x (1) : autorisation d'exécution.

 Exemple :
chmod a+x [Link]
Comment Exécuter un script

 Pour exécuter un script, vous avez le choix de, soit d’utiliser le chemin
relatif , soit d’utiliser le chemin absolu
• Chemin relatif : Il faut être dans le dossier du fichier et faire
./nom_fichier
 Exemple ./[Link]

 Chemin absolu : Peut importe là où on se trouve, on précise le chemin

allant de la racine jusqu’au fichier à exécuter
 Exemple : /home/franck/[Link]
en supposant que c’est le chemin absolu vers le fichier
ECRIRE UN SCRIPT

 Editeur
On peut utiliser n’importe quel éditeur disponible dans l’environnement
Exemple : gedit, emacs, vi, vim, nano sous Linux ; notepad++ sous windows

 Le Shebang
C’est la première ligne qu’on trouve dans un fichier de script shell
#!/bin/bash
Il commence par un « # » (ce qui correspond la plupart du temps à des
commentaires) puis d’un « ! » et enfin le chemin menant au programme Bash
Shell
ECRIRE UN SCRIPT

 Le Shebang
On y indique le chemin de l’interpréteur qui va lire le script.
Il en existe d’autres. Ci-dessous, quelques exemples :
• #!/bin/sh
• #!/bin/csh
• #!/bin/zsh
• #!/usr/bin/python
Les Commentaires

 Les commentaires permettent de rendre des parties du contenu du fichier de script non
interprétées par l’interpréteur
 Une ligne commentée commence par le caractère #
 On peut aussi commenter la fin d‘une ligne
 Mais il n‘existe aucun moyen natif pour commenter plusieurs lignes à la fois. Mais il
existe des solutions.
 Ainsi, en dehors du shebang, toute ligne commençant par # ne sera pas interprétée

#!/bin/bash
echo "Bonjour tout le monde"
#Ceci est un commentaire
echo "Merci pour l’explication" #Ceci ne sera pas interprété
Les Variables

 Ce sont des espaces de stockage qui possèdent un nom

Il existe deux catégories de variables : Les variables définies par l’utilisateur et les
variables prédéfinies (variables prépositionnées, variables d’environnement, etc.)

 Variables définies par l’utilisateur

Le nom d‘une variable est un identificateur
• Caractères alpha-numériques
• Ne peut commencer par un chiffre
• Peut contenir le caractère sous-tiret (_)
 Le nom d‘une variable est sensible à la casse : une distinction est faite entre majuscule
et minuscule
 Par convention, il est en MAJUSCULE
Les Variables

 Syntaxe de déclaration
NOM_DE_LA_VARIABLE="valeur"
Nota : Il ne faut pas mettre d'espace entre le nom de la variable, le signe = et "

 Syntaxe d’utilisation
Pour utiliser le contenu d’une variable, il faut faire précéder le nom de la variable
par un $

Un exemple illustratif se trouve sur la page suivante

Les Variables

#!/bin/bash
PRENOM= " Franck"
NOM= " ADJEGAN"
echo "Bonjour $PRENOM $NOM et bienvenue au cours de script shell"

#En supposant que le fichier du code ci-dessus se nome [Link], et qu’on a

déjà défini les droits d’accès appropriés dessus, son exécution se fera comme
suit :
./[Link]
#ce qui donnera comme résultat :
Bonjour Franck ADJEGAN et bienvenue au cours de script shell
Les Variables

 Nota : Dans certains cas, on est obligé d’utiliser les accolades pour entourer le nom
de la variable
#!/bin/bash
PRENOM="Luc"
NOM="SAGBO"
AGE="18"
echo "Bonjour $PRENOM ${NOM}, vous avez ${AGE}ans"

./[Link]
Bonjour Luc SAGBO, vous avez 18ans

Nota : Ici, si on ne mettait pas les accolades, on aurait de problèmes dans l’interprétation de $NOM,
à cause de la virgule qui est collée au nom de la variable. De même on n’aurait pas pu afficher l'âge
avec la chaine ans collée à la variable désignant l'âge.
Les Variables

 Assigner les sorties de commandes à une variable

Il est tout a fait possible d'assigner la sortie standard d'une commande à une variable en la mettant
entre parenthèses
#!/bin/bash
PRENOM="Luc"
NOM="SAGBO"
MACHINE=$(hostname)
echo "Bonjour $PRENOM $NOM et bienvenu sur la machine ${MACHINE}. "

Une autre syntaxe est également possible suivant le script et elle utilise le symbole ` (alt gr + 7) à
la place du $() pour exécuter une commande.
#!/bin/bash
PRENOM="Luc"
NOM="SAGBO"
MACHINE=`hostname`
echo "Bonjour $PRENOM $NOM et bienvenu sur la machine ${MACHINE}."
LES VARIABLES SPÉCIFIQUES :
PRÉPOSITIONNÉES
 Quelques variables spécifiques au shell qui permettent de récupérer des informations sur les
arguments passés ou sur l'exécution en cours.
• $0 indique le nom d'une commande (nom du shell ou du script shell en cours d’exécutionou)
• $# indique le nombre de paramètres positionnels d'une commande (nombre total
d'arguments passés)
• $$ indique le numéro de processus du shell courant (PID : Process ID)
• $? Code qui indique un résultat lié au déroulement de la dernière commande exécutée
• 0 : Pas d'erreur. Autre valeur : cas contraire.
• $* ensemble des paramètres (arguments) d'une commande (sous forme de liste séparée par
le l'IFS)
• $@ ensemble des paramètres (arguments) d'une commande (sous forme de liste séparée par
des espaces)
• $1 à $9 représentent des paramètres positionnels (les arguments passés à une commande ou
à un script).
LES VARIABLES D'ENVIRONNEMENT

 PATH représente les différents chemins où se trouvent les exécutables.

 PS1 affiche la structure du prompt principal, ou celui par défaut.
 HOME contient le répertoire de base de l'utilisateur.
 SHELL indique le shell utilisé par l'utilisateur.
 LANG indique la langue utilisée.
 TEMP contient le chemin où les processus stockent les fichiers temporaires.
 OSTYPE indique le type de système d'exploitation.
 LD_LIBRARY_PATH contient les différents chemins où se trouvent les
bibliothèques.
 USER indique l'utilisateur connecté à la session courante.
 EDITOR indique l'éditeur utilisé par défaut au sein de la session courante.
LES VARIABLES D'ENVIRONNEMENT

 MANPATH contient l'ensemble des répertoires où se situent les fichiers MAN.

 MANPATH indique le nom du fichier contenant l'historique des commandes enregistrées.
 HISTSIZE valeur limitant le nombre de commandes enregistrées dans le fichier historique.
 PWD contient le chemin du répertoire actuel.

Nota : La liste des variables spéciales et celles d’environnement présentées ici n’est que
partielle. Pour connaitre par exemple toutes les variables d’environnement, il suffit de taper la
commande env dans la console.
Vous êtes aussi priés de tester chacune des variables présentées sur les pages 16 à 18 pour
mieux en comprendre l’utilité.
Pour tester une des variable, il suffit de faire
echo $NOM_VARIABLE
LES CONSTANTES : VARIABLES NON
MODIFIABLES
 La notion de constante n’existe pas vraiment en Shell script.
Mais comme une constante n’est qu’une variable non modifiable, il y a la
possibilité d’utiliser le mot clé readonly pour rendre une variable non
modifiable
 Syntaxe : readonly NOM_CONSTANTE="Valeur"
On vient donc de définir une variable comme une constante.
Exercice d’ application

 Creez un script Shell qui permettra de

1-Creez un fichier [Link] dans le répertoire Documents

2-Inserez votre Nom et Prénom dans le fichier [Link] en utilisant des
variables en en leur assignant des valeurs.
3-Copier le fichier vers le répertoire Documents/TEST que vous aurez creer
dans le répertoire tout en renommant le fichier en ajoutant la date du jour.
4-Afficher le contenu du fichier
5- Effectuer quelques contrôles d’ erreur si necessaire
LES TESTS

 Lorsque vous tapez une commande, vous pouvez prendre le temps

d'analyser la réponse du système et prendre une décision en fonction de
cette réponse.
 Il est tout à fait possible d'effectuer les mêmes étapes avec le scripting
Shell grâce aux tests. Il existe deux formes de tests.
 La syntaxe de la première forme, à base de crochets, est la suivante :
[ voici-la-condition-du-test-a-vérifier ]
 Il est important de respecter les espaces après le symbole [ mais
également avant le ].
LES TESTS

 Exemple 1 : Vérifier si le fichier /home/luc/test existe

[ -e /home/luc/test ]
• La commande retourne la valeur 0 (True) si le fichier existe
• La commande retourne la valeur 1 (False) si le fichier n'existe pas
 Exemple 2 : Vérifier si la chaine contenue dans la variable NOM est vide ou non
[ -z NOM ]
• La commande retourne la valeur 0 (True) si la chaine est vide
• La commande retourne la valeur 1 (False) si la chaine n’est pas vide
 Nota : Pour connaitre la valeur retournée par l’exécution d’une commande, il
faut lire le contenu de la variable spéciale $? Après avoir exécuté la commande
LES TESTS

 Opérateurs principaux pour les tests

• -e : 0 (True) si le fichier existe
• -d : 0 (True) s'il s'agit d'un dossier
• -r : 0 (True) si le fichier est disponible en lecture pour l'utilisateur
• -s : 0 (True) si le fichier existe et n'est pas vide
• -w : 0 (True) si le fichier est disponible en écriture pour l'utilisateur
• -x : 0 (True) si le fichier est disponible en exécution pour l'utilisateur
• -z : 0 si la chaîne de caractère est vide et 1 si elle ne l'est pas
• –n : 1 si la chaîne de caractère est vide et 0 si elle ne l'est pas
 Nota : Les deux dernières options s’utilisent sur les chaines de caractères
LES TESTS

 Comparer deux chaînes : Soit le script shell [Link] dont le code est ci
dessous
#!/bin/bash
PRENOM='Luc'
NOM='SAGBO'
[ $PRENOM = $NOM ]
echo $?

./[Link]
1
 Nota : Avec =, le script nous renvoie 0 si les deux chaînes sont identiques et 1 si
elles ne le sont pas
LES TESTS

 Comparer deux chaînes

#!/bin/bash
PRENOM='Luc'
NOM='SAGBO'
[ $PRENOM != $NOM ]
echo $?

./[Link]
0

 Nota : Avec !=, le script nous renvoie 0 si les deux chaînes ne sont pas identiques et 1
si elles le sont
LES OPÉRATEURS

 Les opérateurs permettent de faire des opérations sur les données et les
valeurs.
❑ Opérateurs arithmétiques

 Nota : on peut aussi utiliser l’opérateur expr pour évaluer une

expression.
 Exemple :
echo `expr 2 + 2 `
LES OPÉRATEURS

❑ Opérateurs logiques

❑ Opérateurs de comparaison
LES OPÉRATEURS

❑Opérateurs d’affectation, d’incrémentation et associatifs

LES OPÉRATEURS
ENTRÉE UTILISATEUR

 La commande read permet d'accepter les données venant de l’entrée standard (STDIN).
L’utilisateur peut dont entrer des données à partir du clavier.
 Syntaxe d’utilisation
La syntaxe de base est la suivante : read NOM_VARIABLE

Lorsqu’on souhaite afficher un message indicatif avant la lecture, on peut utiliser l’option –p
read –p "Le message indicatif : " NOM_VARIABLE

 Exemple :
read –p "Entrez votre nom : " NOM
Ce qui est équivalent à :
echo "Entrez votre nom : "
read NOM
ENTRÉE UTILISATEUR

 On peut lire dans plusieurs variables à la fois avec une seule instruction
read
Exemple : read NOM PRENOM
 Nota : lorsque à la saisie, l’utilisateur entre :
- moins de valeurs que de variables, les dernières variables sont
vides
- plus de valeurs que de variables, la dernière variable prend le
reste des valeurs, séparateurs compris
Le séparateur par défaut est soit le caractère espace, soit tabulation (\t) ou
soit saut de ligne (\n). Mais on peut définir un autre séparateur.
On change pour cela la valeur par défaut de la variable prédéfinie IFS
ENTRÉE UTILISATEUR

 Exemple :
franck@osboxes:~$ OLDIFS="$IFS"
franck@osboxes:~$ IFS="|"
franck@osboxes:~$ read A B C
azerty|qwerty|papou
franck@osboxes:~$ echo $B
qwerty

franck@osboxes:~$ IFS="$OLDIFS"
franck@osboxes:~$ read A B C
azerty|qwerty|papou
franck@osboxes:~$ echo $A
azerty|qwerty|papou
ENTRÉE UTILISATEUR

 On a également la possibilité d’utiliser le commande read pour lire une

donnée sans l’afficher lors de la saisie. Ceci peut-être très utile pour la
saisie de mot de passe. Pour cela on ajoute l’option –s à l’option –p.
Nota : avec l'option -s, il est recommandé d'ajouter la commande echo
pour afficher un saut de ligne.

franck@osboxes:~$ read -p “Login ? " LOGIN

franck@osboxes:~$ read -s -p “Mot de Passe ? " PASSWD; echo
LES STRUCTURE DE CONTRÔLE

 Il y a deux catégories de structures de contrôle :

 Les Structure conditionnelles
o La structure if avec toutes ses variantes
o La structure case

 Les structures répétitives ou itératives

o La boucle for
o La boucle while
o La boucle until
 LES STRUCTURE DE CONTRÔLE
 L es conditions : le cas de if
2eME
1er Cas
Cas 3eme
Cas

if [ condition-est-vraie if [ condition1-est-vraie ]
] then
if [ condition-est-vraie ] command1
then
then
command1 elif [ condition2-est-
command1 vraie ]
command2
else
command2 then
fi command2
fi else
command3
fi
LES STRUCTURE DE CONTRÔLE

 Exercice :
Créer un script qui demande à l'utilisateur de saisir une note comprise
entre 0 et 20 et qui affiche un message en fonction de cette note :
 "très bien" si la note est entre 16 et 20, 16 inclus ;
 "bien" lorsqu'elle est entre 14 et 16, 16 exclue ;
 "assez bien" si la note est entre 12 et 14, 14 exclue ;
 "passable" si la note est entre 10 et 12 ; 12 exclue
 "insuffisant" si la note est inférieur à 10.
 LES STRUCTURE DE CONTRÔLE
 L es conditions : le cas de case
Exempl
Syntax e
Syntax e
e

case <valeur> in case "$VARIABLE" in

case "$1" in
[PATTERN [I PATTERN] ) premier_cas) start)
<liste d'instructions> commande1 `/etc/init.d/apache2 start`
;;
;;] ;;
stop)
esac deuxieme_cas) kill $(cat /var/run/apache2/[Link])
commande2 ;;
*)
;;
echo « Indiquez start ou stop«
troisieme_cas) exit 1
commande3 ;;
;; esac
esa
LES STRUCTURE DE CONTRÔLE

 Les Boucles : la boucle for

Syntaxe d’utilisation

for VARIABLE in OBJET1 OBJET2 OBJET3 OBJETn

do
command1
command2
done
LES STRUCTURE DE CONTRÔLE

 Les Boucles : la boucle for

Exemple :
#!/bin/bash #!/bin/bash

for CHIFFRE in 10 11 12 13 for CHIFFRE in {10..13

do do
echo "Chiffre : $CHIFFRE" echo "Chiffre : $CHIFFRE"
Done Done

Exercice
 Créer un script qui prend un nombre en saisie et l'élève à sa propre puissance.
C'est un peu le même principe que la factorielle mais cette fois, l'usage de la
boucle for est imposé
LES STRUCTURE DE CONTRÔLE

 Les Boucles : la boucle While :

Syntaxe d’utilisation
while [ la-condition-est-vraie ]
do
command1
command2
done
LES STRUCTURE DE CONTRÔLE

 Les Boucles : la boucle While :

Exemple :
#!/bin/bash
while [ -z $PRENOM ]
do
read –p "Quel est votre prenom ?" PRENOM
done
echo "Votre prenom est $PRENOM"

Exercice
Création d'un jeu qui permet à l'utilisateur de deviner un chiffre généré par le script entre 1 et 50. A
chaque fois que l'utilisateur entre un chiffre, le script lui indique si le chiffre à trouver est supérieur ou
inférieur à celui qu'il a entré, etc.
LES STRUCTURE DE CONTRÔLE

 Les Boucles : la boucle Until :

La boucle until fait la même chose que la boucle while, à la différence qu’ici
la boucle est exécutée tant que la condition est fausse (contrairement à la
boucle while)
#!/bin/bash
until [ -n "$PRENOM" ]
do
read –p "Quel est votre prenom ?" PRENOM
done
echo "Votre prenom est $PRENOM"
LES MENUS : BOUCLE «SELECT»

 La commande select est une structure de contrôle de type itérative qui

est utilisée pour réaliser un menu.
 Syntaxe :
select nom_var in item1 item2 item3 ... itemn
do
commandes
done
 LES MENUS : BOUCLE «SELECT»
 Exemple :
PS3="Votre choix : "
select texte in "- Traitement 1" "- Traitement 2" "- Quitter"
do
echo "Votre choix est $REPLY : $texte"
case $REPLY in
1)
echo "Lancement traitement 1"
;;
2)
echo "Lancement traitement 2"
;;
3)
echo "Au revoir"
exit 0
;;
*)
echo "Choix incorrect : 1 - 2 - 3"
;;
esac
LES MENUS : BOUCLE «SELECT»

 Nota : La liste des items sera affichée à l'écran à chaque tour de

boucle et chaque item est indicé automatiquement.
 • La variable lib_var sera initialisée avec l'item correspondant au choix
de l'utilisateur.
 • La commande select s’accompagne de l’utilisation de deux autres
variables prédéfinies :
❖ La variable PS3 qui représente le prompt utilisé pour la
saisie du choix de l'utilisateur.
❖ La variable REPLY qui contient l'indice de l'item
sélectionné.
TRAVAUX PRATIQUES

Exercice : Gestion de Menu en Shell

Écrivez un script Shell qui propose un menu interactif permettant à l'utilisateur de :

Afficher la date et l'heure actuelles.

Afficher le contenu d'un répertoire choisi par l'utilisateur.
Vérifier si un nombre donné est pair ou impair.
Deviner un nombre aléatoire entre 1 et 10.
Quitter le programme.
Le script doit :

Utiliser if, elif, else pour gérer les conditions.

Utiliser case pour gérer les choix du menu.
Utiliser while pour afficher le menu en boucle jusqu'à ce que l'utilisateur choisisse de quitter.
Utiliser for pour afficher le contenu d'un répertoire.
Vérifier si l'entrée utilisateur est correcte avant de poursuivre.
LES FONCTIONS

 Une fonction est un block de code désigné sous un nom et spécialisé

dans un traitement. Les fonctions présentent plusieurs avantages, à
savoir :
 écrire un block de code une fois, et le réutiliser autant de
fois que nécessaire
 avoir du code modulaire et aéré
 faire facilement la maintenance du code

Il existe deux syntaxe de définition d’une fonction. Les deux sont

présentées sur la page qui suit :
LES FONCTIONS

 #utilisation du mot clé "function"

function nom_de_la_fonction(){
command1
command2
}
#non utilisation du mot clé "function"
nom_de_la_fonction(){
command1
command2
}
LES FONCTIONS
 Appel d’une fonction
On se sert de son nom sans toutefois le faire suivre des parenthèses
#!/bin/bash
function check_server() {
ping -c 1 [Link] #on suppose que l’IP du serveur est [Link]
if [ $? -eq 0 ] then ;
echo "Le serveur est joignable"
else
echo "Le serveur n’est pas joignable"
fi
}
check_server
#ceci est l’appel de la fonction

PING [Link] ([Link]) 56(84) bytes of data.

64 bytes from [Link]: icmp_seq=1 ttl=63 time=2.51 ms
--- [Link] ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 2.508/2.508/2.508/0.000 ms
serveur joignable
 LES FONCTIONS
 Passage de paramètres à une fonction
les fonctions peuvent accepter des paramètres comme d’ailleurs c’est le cas avec les
scripts en général.
Les N paramètres sont accessibles à travers les variables spéciales $1, $2, …, $n.
Naturellement, $0 fait référence au nom du script lancé.
#!/bin/bash
function check_server() {
ping -c $2 $1 #ici $2 représente le nombre de paquets à lancer, $1 représente l’adresse IP à atteindre
if [ $? -eq 0 ] then ;
echo "Le serveur est joignable"
else
echo "Le serveur n’est pas joignable"
fi
}
 LES FONCTIONS
 Variables Locales et Globales

Les variables locales ne sont visibles et accessibles qu’à l’intérieur de la

fonction.
Par contre une variable globale est accessible à l’intérieur d’une fonction.
Mais pour cela il faudra la déclarer avant la fonction.
On peut néanmoins déclarer une variable globale dans une fonction. Dans ce
cas, elle ne sera accessible qu’une fois la fonction appelée.
Pour déclarer une variable locale on doit précéder le nom de la variable du
mot clé local
 LES FONCTIONS
 Variables Locales et Globales : Exemple

#!/bin/bash
VAR1="Globale1" En exécutant le code, on se rend compte
que toutes les variables sont disponibles
function test_variables() { dans la fonction. Mais une fois en dehors de
echo "La variable $VAR1 est accessible" la fonction, la variable $VAR3 n’est plus
VAR2="Globale2" accessible. Je vous propose de tester ce
code et de voir le résultat.
local VAR3="Locale1"
echo "variables $VAR2 et $VAR3"
}
test_variables
echo "les variables $VAR1 et $VAR2 et $VAR3"
 LES FONCTIONS

 Variables Locales et Globales :

Exemple

Pour lancer une fonction qui est définie dans Une fois que le fichier est chargé, on peut
un appeler la fonction en tapant son nom suivi
de ses arguments éventuels.
fichier de script shell à partir d'une ligne de
$ source mon_script.sh
commande (prompt), on doit d'abord
charger le fichier de script en utilisant la $ ma_fonction argument1 argument2
commande source ou . (point). Voici la
syntaxe générale :
 Nota : faire attention au chemin d’accès
 $ source nom_du_fichier.sh au script
ou
 $ . nom_du_fichier.sh
LES WILDCARDS : CARACTÈRES
GÉNÉRIQUES

Un wildcard est un caractère (ou une chaîne de caractères) générique ou de

substitution qui est utilisé dans une expression pour prendre un certain
nombre de valeurs
On les utilise avec la plupart des commandes, mais très souvent avec les
commandes ls, mkdir et rm
Caractères spéciaux : ? et *
? Désigne exactement un seul caractère

 Exemple
$ echo fichier?.txt #fichiers [Link], [Link], [Link], si ces
fichiers existent dans le dossier courant
$echo t?t?.txt #fichiers [Link], [Link], [Link], si des fichiers comme ça
existent dans le dossier courant
LES WILDCARDS : CARACTÈRES
GÉNÉRIQUES

 * Désigne n’importe quel caractère ou suite de caractères, y compris le

caractère vide
Exemple
$ echo *t* #peut donner table, [Link], [Link], toise, si ces fichiers ou
dossiers existent
$ echo t*.txt #tous les fichiers txt commençant par t, s’ils existent

Nota : On ne peut pas utiliser ? ou * au début pour retrouver les fichiers

préfixés par le caractère point (.)
Il faut le spécifier explicitement avant de mettre ? ou *
Exemple
$ echo .*
LES WILDCARDS : CARACTÈRES
GÉNÉRIQUES

Les classes de caractères :