Module : Système et Scripting
Année Universitaire
2024-2025
Planification & Informations
● Chapitre 1 : Introduction & Commandes de base
● Chapitre 2 : Langage de programmation Shell
● Chapitre 3 : Conditions & Boucles en Shell
● Chapitre 4 : Sous-programmes en Shell
Système & Scripting
Chapitre II : Langage de programmation Shell
Plan
1) Shell : Le principe des scripts
2) Fonctionnement des scripts
3) Exécution des scripts
4) composants des scripts
5) Déclaration des variables
6) Affichage des variables avec echo
7) Saisie des variables avec read
8) Les variables d'environnement
9) Les variables spéciales
10)Tableaux
11)Expr : arithmétique
12)Expr : manipulation des chaînes de caractères
Le principe des scripts
Un script est un ensemble de commandes qui sont regroupées dans un
fichier exécutable. Les avantages sont :
● Assembler des commandes simples pour réaliser des actions
complexes
● Regrouper des actions que l'on désire exécuter plus d'une fois
● Réaliser un outil à mettre à la disposition de plusieurs personnes
● Un script est un programme interprété et non compilé.
L'intérêt de maîtriser l'art du scripting réside dans la capacité
d'automatiser des tâches complexes ainsi que d'être capable de lire et
de modifier les scripts existants sur un système.
Fonctionnement des scripts
Pour fonctionner un script doit répondre à plusieurs critères :
1) Etre exécutable pour l'utilisateur au niveau de la protection du fichier
chmod +x nom_du_script.sh
2) Avoir l'appel à l'interpréteur dans sa première ligne
#!/bin/bash
Fonctionnement des scripts
● La première ligne commençant par #! indique à quel interpréteur le
script doit être confié.
● Il existe de nombreux interpréteurs possibles, par exemple:
▪ #!/bin/sh ▪ #!/usr/bin/tcl
▪ #!/bin/bash ▪ #!/bin/sed -f
▪ #!/usr/bin/perl ▪ #!/bin/awk -f
Exécution des scripts
1) Exécution via un Shell spécifique
Si le script est exécutable, il suffit de passer le script en argument à un Shell.
bash monscript.sh
2) Exécution directe avec les permissions appropriées
Si le script est configuré avec des droits d’exécution (chmod +x), il peut être lancé directement en
indiquant son chemin relatif ou absolu. Par exemple :
./monscript.sh
3) Exécution dans le contexte du Shell courant
Une autre méthode consiste à exécuter le script dans le même environnement que le shell appelant,
ce qui signifie que les modifications apportées (par exemple, l’exportation de variables) affecteront le
Shell actuel.
. ./monscript.sh ou
source monscript.sh
Composants des scripts
❖ une commande Shell de base : find, cut ou echo
❖ une variable : $var
❖ un commentaire : #ceci est un commentaire: Ce qui suit ne sera pas exécuté. On
peut commencer un commentaire n'importe où sur une ligne et il se termine
obligatoirement à la fin de la ligne. Par contre, les # dans des chaînes de
caractères ne sont pas des commentaires.
❖ une fonction : définition d'un sous programme ou procédure
❖ une structure de contrôle : if-then-else, for ou while
❖ # est un commentaire,; est un séparateur de commandes, il permet de placer
plusieurs commandes sur une seule ligne.
echo "Le fichier $nomfichier existe"; cp $nomfichier $nomfichier.sauve
Déclaration des variables
❖ création un nouveau script variables.sh :
$ nano variables.sh
❖ La première ligne scripts doit indiquer quel shell est utilisé .
#!/bin/bash
❖ Définition des variables.
⮚ Toute variable possède un nom et une valeur :
#!/bin/bash
message='Bonjour ESPRIT '
❖ Exécution du script
$ ./variables.sh
Affichage des variables avec echo
● La commande echo permet d'afficher une ligne.
$ echo Salut ESPRIT
Salut ESPRIT
● lors de insertion des retours à la ligne, il faudra activer l’option -e et
utiliser le symbole \n :
$ echo -e "Message\n Autre ligne"
Message
Autre ligne
● Afficher une variable
#!/bin/bash
message='Bonjour ESPRIT'
echo $message
Affichage des variables avec echo
❖ Affichage du texte et variable.
#!/bin/bash
message='Bonjour Esprit'
echo 'Le message est : $message'
Le problème est que cela ne fonctionne pas car cela affiche :
Le message est : $message
❖ La compréhension des quotes
⮚ Il existe trois types de quotes :
• les apostrophes ' ' (simples quotes)
• les guillemets " " (doubles quotes)
• les accents graves ` ` (back quotes)
Affichage des variables avec echo
Les « quotes »
Avec de simples quotes: la variable n'est pas analysée et le $ est affiché tel quel:
#!/bin/bash
message='Bonjour Esprit' Le message est : $message
echo 'Le message est : $message'
Avec les doubles quotes: ils demandent à bash d'analyser le contenu du message
s'il a trouvé des symboles spéciaux (comme des variables), il les interprète.
#!/bin/bash
message='Bonjour Esprit' Le message est : Bonjour Esprit
echo " Le message est : $message "
Avec les back quotes: ils demandent à bash d'exécuter ce qui se trouve à
l'intérieur.
#!/bin/bash
message=`pwd` Vous êtes dans /home/Esprit
echo "Vous êtes dans $message"
Saisie des variables avec read
● La commande read lit son entrée standard et affecte les valeurs saisies
dans la ou les variables passées en argument.
#!/bin/bash
read nom
echo "Bonjour $nom "
● Affecter simultanément une valeur à plusieurs variables
#!/bin/bash
read nom prenom
echo "Bonjour $nom $prenom"
● Afficher un message de prompt
#!/bin/bash
read -p 'Entrez votre nom : ' nom
echo "Bonjour $nom "
Saisie des variables avec read
Exemple
Les variables d'environnement
● une variable définie dans un programme A ne sera pas utilisable dans un
programme B.
● Les variables d'environnement sont des variables que l'on peut utiliser
dans n'importe quel programme. On parle aussi parfois de variables
globales.
$ printenv
⮚ la commande env :
PATH=:/usr/share/glade3/pixmaps
TERM=xterm
SHELL=/bin/bash
USER=ESPRIT
PATH=/home/esprit/bin:/usr/local/sbin:/usr/l
ocal/bin:/usr/sbin: PWD=/home/mateo21/bin
EDITOR=nano
HOME=/home/esprit
Les variables d'environnement
• SHELL: indique quel type de shell est en cours d'utilisation (sh, bash, ksh)
• PATH: une liste des répertoires qui contiennent des exécutables que vous
souhaitez pouvoir lancer sans indiquer leur répertoire.
• EDITOR: l'éditeur de texte par défaut qui s'ouvre lorsque cela est
nécessaire ;
• HOME: la position de votre dossierhome ;
• PWD: le dossier dans lequel vous vous trouvez ;
#!/bin/bash
Votre éditeur par défaut est nano
echo "Votre éditeur par défaut est $EDITOR"
Les variables d'environnement
Création des variables d'environnement
Utilisation des variables d'environnement
Les variables spéciales
Le script Shell récupère les arguments de la ligne de commande dans
des variables réservées appelées Paramètres Positionnels
Variables spéciales Signification
$# Nombre d’arguments reçus par le script
$0 Le nom du script lui-même
$1 $2 … $9 ${10} $1 est la valeur du premier argument, $2 la valeur du
second…
$* Liste des arguments
$0 Le Nombre d’arguments
Le 1er argument $1
Substitution des variables
● $ Substitution de variable (contenu d'une variable).
echo $var1
var1=5 # 5
var2=23Esprit echo $var2
# 23Esprit
● ${} substitution de paramètres
● ${parametre} Identique à $parametre, c'est-à-dire la valeur de la
variable paramètre.
● Concaténation de variables avec des chaînes
Peut être utilisé pour concaténer des variables avec des suites de
caractères (strings).
votre_id=${USER}-sur-${HOSTNAME}
Tableaux
1. Création d’un tableau
● Quatre méthodes pour créer un tableau:
⮚ Avec la commande declare et l'option -a :
declare -a nom-tableau=(valeur0 valeur1 valeur2 ...)
⮚ Directement :
nom-tableau=(valeur0 valeur1 ...)
⮚ Autre syntaxe :
nom-tableau=([indice0]=valeur0 [indice1]=valeur1 ...)
Assigner un élément
nomtableau[indice]=valeur
$ tab[0]=10 $ tab[2]=12
2. Affichage des éléments
Exemple:Affichage de les éléments d’indice 0 et d’indice 2:
$ echo ${tab[0]} $ echo ${tab[2]}
10 12
Tableaux
3. Accès à toutes les valeurs d'un tableau
● Tous les éléments d'un tableau sont accessibles avec chacune de
ces deux syntaxes :
${nom-tableau[*]} ${nom-tableau[@]}
4. Comptage des éléments dans un tableau
● Le nombre d'éléments d'un tableau est accessible par chacune de
ces deux syntaxes :
${#nomtableau[*]} ${#nomtableau[@]}
Tableaux
5- Ajout d’un élément à la fin du tableau:
tableau[${#tableau[*]}]=élément
Tableaux
6- Ajout d’un élément au début d'un tableau :
tableau=( element ${tableau[*]} )
7- Supprimer un tableau:
unset nom-tableau
8- Supprimer la case d'un tableau :
unset nom-tableau[indice]
Expr : arithmétique
La commande « expr » évalue ses arguments et écrit le résultat sur
la sortie standard. La première utilisation de « expr » concerne les
opérations arithmétiques simples.
Les opérateurs arithmétiques sont :
● + : addition ;
● - : soustraction ;
● \* : multiplication ;
● / : division entière ;
● % : reste de la division ;
● \( et \) : parenthèses.
Expr : arithmétique
Exemple:
Syntaxe1
Expr : arithmétique
Exemple
Syntaxe2
Expr : manipulation des chaînes
1- Longueur de chaînes de caractères
⮚ ${#chaine}
⮚ expr length $chaine
⮚ expr "$chaine" : ‘.*’
Expr : manipulation des chaînes
2- Longueur de sous-chaînes correspondant à un motif
Au début d'une chaîne
expr match "$chaine" 'He' # Affiche : 2 (longueur de la correspondance)
Utiliser expr avec un motif :
expr "$chaine" : 'He.*' # Affiche : 5 (longueur de la correspondance)
Trouver la position d'une sous-chaîne dans une chaîne :
expr index "$chaine" 'l' # Affiche : 3 (première occurrence de 'l')
Expr : manipulation des chaînes
3- Extraction d'une sous-chaîne
Extraire une sous-chaîne à une position donnée :
${chaine:position:longueur} #extrait $longueur caractères d'une sous-chaîne de $chaine à la position $position
Utiliser expr pour extraire une sous-chaîne à une position donnée :
expr substr $chaine position longueur #extrait $longueur caractères à partir de $chaine en commençant à $position
Expr : manipulation des chaînes
Extrait $souschaine à partir du début de $chaine : où $souschaine est une expression rationnelle
expr "$chaine" : '\($souschaine\)‘
Extrait $souschaine à la fin de $chaine : où $souschaine est une expression rationnelle.
expr "$chaine" : '.*\($souschaine\)‘
Expr : manipulation des chaînes
4- Suppression de sous-chaînes
Supprimer la correspondance la plus petite de $souschaine à partir
du début de $chaine :
${chaine#souschaine}
Supprimer la correspondance la plus grande de $souschaine à partir
du début de $chaine :
${chaine##souschaine}
Expr : manipulation des chaînes
4- Suppression de sous-chaînes
Supprimer la plus petite correspondance de $souschaine à partir de la fin de
$chaine
${chaine%souschaine}
Supprimer la correspondance la plus grande de $souschaine à partir de la fin
de $chaine
${chaine%%souschaine}
Expr : manipulation des chaînes
5- Remplacement de sous-chaîne
Remplacer la première correspondance de souschaine par remplacement
${chaine/souschaine/remplacement}
Remplacer toutes les correspondances de souschaine avec remplacement
${chaine//souschaine/remplacement}
