Programmation Shell
Programmation Shell
Script bash : Définition
– fichier texte contenant une suite de commandes shell
– s’exécute comme une commande unique
– peut définir et utiliser des variables
– on peut lui passer des paramètres
– gère les entrées/sorties et les redirections
– possède des structures conditionnelles et itératives
– on peut définir des fonctions internes
=> Véritable langage de programmation interprété
1
Programmation Shell
Script bash : Exemple
#!/bin/bash
# script bonjour
# affiche un salut à l'utilisateur qui l'a lancé
# variable d'environnement $USER : nom de login
echo ---- Bonjour $USER -----
# l'option -n empêche le passage à la ligne
# le ; sert de séparateur des commandes sur la ligne
echo -n "Nous sommes le " ; date
# recherche $USER en début de ligne dans passwd
# puis extraction de l'uid au 3ème champ, et affichage
echo "Ton numéro d'utilisateur est : "\
$(grep "$USER" /etc/passwd | cut -d: -f3)
Programmation Shell
Script bash : Exécution
– $ bash script
– Avec les bons droits :
• $ chmod u+x script
• $ ./script
– En faire une commande :
• $ mv script ~/bin # Créer le dossier avant !
• $ export PATH=~/bin:$PATH # pour le shell courant
• $ echo PATH=~/bin:$PATH >> $HOME/.bashrc # permanent
2
Programmation Shell
Structure d’un script bash
– Première ligne : #! /bin/bash
• #! : (appelé sha-bang ) indique au système que ce fichier est
un ensemble de commandes à exécuter par l’interpréteur
dont le chemin suit
– par exemple : /bin/sh, /usr/bin/perl, /bin/awk, etc.
– /bin/bash lance bash
– Puis séquence structurée de commandes shell
– Sortie implicite du script à la fin du fichier
• Sortie explicite avec la commande exit
Variables du shell
Deux types de variables
– Variables d’environnement
• existent pour tout processus (cf. /proc/PID/environ)
• transmises d’un processus père à ses fils
• nom généralement en majuscules
• modifient le comportement de certains logiciels
– Variables locales à un shell
• définies uniquement pour un processus shell particulier
• ses processus fils n’en héritent pas
• nom généralement en minuscules
Transformation variable locale -> variable d’environnement
export NOM_DE_VARIABLE
Définition directe d’une variable d’environnement :
export NOM_DE_VARIABLE=VALEUR
3
Variables du shell
Variables d’environnement
– Définition
• ensemble de variables (chaînes de caractères)
• associées aux processus modifiables, héritées d’un processus à l’autre
• chaque processus sa propre copie des variables.
– Commande pour lister les variables : env
– Variables standard
SHELL=/bin/bash
TERM=xterm-256color
USER=user
PATH=/usr/local/bin:/usr/bin:/bin:/usr/games:/users/info/pub/bin
PWD=/home/user
PS1=\[\033]0;[\u@\h:\w]\007\]\u@\h:\w\$
HOME =/home/user
– Préférences personnelles :
PAGER=less
EDITOR=gedit
BROWSER=firefox
Programmation Shell
Les variables d’environnement : $PATH
– Sa valeur est une liste de répertoires séparés par le signe :
PATH=/bin:/usr/bin:/usr/local/bin:/usr/X11/bin
– Lors de chaque appel de commande, l’interpréteur parcourt
cette liste dans l’ordre à la recherche d’un fichier portant le
nom de la commande,
– Dès qu’il rencontre un tel fichier, il met fin à sa recherche et
exécute le fichier
Rôle de $PATH
– Il s’agit d’une liste de répertoires que l’interpréteur parcours
automatiquement et séquentiellement (par défaut) si aucun
chemin n’est donné pour trouver le fichier exécutable,
4
Programmation Shell
La commande which
– which nom_de_la_commande : affiche le chemin du
fichier correspondant à une commande.
– Parcours successivement les répertoires de la variable
$PATH.
– Dès qu’il trouve un fichier correspondant au nom de la
commande il renvoie son chemin.
Programmation Shell
La commande alias
– alias nom_de_la_commande=expression : créer un alias
entre un nom de commande et une expression.
– l’expression est donnée entre quotes : ’expression ...’
– Exemple :
user@MyPc : ~/public_html$ ll
-bash : ll : command not found
user@MyPc : ~/public_html$ alias ll=‘ls -l’
user@MyPc : ~/ public_html $ ll README.html
-rw-r--r-- 1 user prof 161 2021-10-12 17:45 HEADER.html
user@MyPc : ~/ public_html $unalias ll
user@MyPc : ~/ public_html $ ll README.html
-bash : ll : command not found
user@MyPc : ~/ public_html $
5
Programmation Shell
La commande dirname
– dirname chemin : Ne conserve que la partie répertoire
d’un chemin d’accès.
– Il n’est pas nécessaire que le chemin existe dans
l’arborescence.
– Le chemin est traité comme une chaîne de caractères.
– Exemple :
user@MyPc : ~$ dirname /tmp/toto.txt
/tmp
user@MyPc : ~$ dirname a/b/c/d
a/b/c
user@MyPc : ~$
Programmation Shell
La commande basename
– basename chemin : Elimine le chemin d’accès.
– Si un SUFFIXE est indiqué, et s'il est identique à la partie
finale du chemin (NOM), il est éliminé de celui-ci.
– Il n’est pas nécessaire que le chemin existe dans
l’arborescence.
– Le chemin est traité comme une chaîne de caractères.
– Exemple :
user@MyPc : ~$ basename /tmp/toto.txt
toto.txt
user@MyPc : ~$ basename /tmp/toto.txt .txt
toto
user@MyPc : ~$ basename a/b/c/d
d
6
Fichiers de configuration
Fichiers systèmes et utilisateurs
– Les variables d’environnement (et d’autres variables de configuration) sont
définies dans divers fichiers.
– On distingue les fichiers système qui définissent des comportements pour tous
les utilisateurs (stockés dans le répertoire /etc/) des fichiers de configuration
propres à un utilisateur (stockés dans le répertoire personnel)
Configurer son environnement
– Chaque utilisateur peut redéfinir ses variables d’environnement,
– Pour cela il peut modifier le contenu des fichiers .bashrc et .profile dans son
répertoire personnel, Ce sont des fichiers cachés (leur nom commence par un
point : .).
– Pour voir si ils existent il faut utiliser l’option -a de la commende ls.
Fichiers de configuration
Contenu d’un fichier .bashrc
– Redéfinition des variables d’environnement,
– Définition des alias,
– Définition des fonctions,
– et de façon générale toutes les instructions que l’on souhaite
évaluer lors de l’ouverture d’un nouveau shell.
7
Programmation Shell
Les variables locales bash
– Variables de l’interpréteur de commandes :
• non déclarées
• non typées a priori => chaînes de caractères
• pas d’héritage par les processus fils
– Syntaxe d’affectation
variable=valeur (sans espace autour du signe = )
– Référence à la valeur de la variable :
$variable ou, plus précisément, ${variable}
Programmation Shell
Les variables locales bash
– Exemple 1/2 : Se placer dans un répertoire souvent utilisé
Pour sélectionner comme répertoire courant un répertoire dans
lequel on se place souvent et dont le nom est long a taper, on
peut définir une variable contenant le nom du répertoire, et
utiliser le nom de la variable en lieu et place du nom complet du
répertoire :
user@MyPc : ~$ DirTP1=/home/user/TP_LINUX/TP1
user@MyPc : ~$ cd $DirTP1
user@MyPc : ~ TP_LINUX/TP1 $
8
Programmation Shell
Les variables locales bash
– Exemple 2/2 : Afficher des messages personnalises
Cet exemple utilise deux variables Cible et Entete. La même
instruction echo $Entete $Cible affiche des messages différents car la
valeur de la variable Entete a été modifiée entre les deux évaluations.
Cet exemple montre :
• comment on modifie la valeur d’une variable et
• comment une même instruction paramétrée par des variables peut
conduire à des résultats différents selon la valeur des variables.
user@MyPc : ~$ Cible=’A tous’
user@MyPc : ~$ Entete=’Bonjour’
user@MyPc : ~ $ echo $Entete $Cible
Bonjour A tous
user@MyPc : ~$ Entete=’Salut’
user@MyPc : ~ $ echo $Entete $Cible
Salut A tous
Programmation Shell
Les paramètres d’un script
– Les scripts bash acceptent des paramètres
– ./scritp.sh param1 param2 param3
• $# : contient le nombre de param.
• $0 : contient le nom du script exécuté (ici "./script.sh")
• $1 : contient 1er param.
• ···
• $9 : contient 9ème param.
• $* : contient la liste des paramètres
– Exemple 1/2:
user@MyPc : ~$ cat script.sh
#!/bin/bash
echo Le premier parametre est : $1
user@MyPc : ~$ ./script.sh toto
Le premier parametre est : toto
user@MyPc : ~$
9
Programmation Shell
Les paramètres d’un script
– Exemple 2/2:
user@MyPc : ~$ cat script2.sh
# !/bin/bash
echo "Nom du script :" $0
echo "Nombre de parametres :" $#
echo "Premier parametre :" $1
echo "Deuxieme parametre :" $2
user@MyPc : ~$ ./script2.sh toto1 toto2 toto3
Nom du script : ./script2.sh
Nombre de parametres : 3
Premier parametre : toto1
Deuxieme parametre : toto2
user@MyPc : ~$
Programmation Shell
Les Caractères spéciaux (Rappel)
– Définition
• Ce sont des caractères qui :
– peuvent apparaitre sur la ligne de commande,
– prennent un sens particulier lors de l’interprétation
– Caractères spéciaux déjà vus
10
Programmation Shell
Les Caractères spéciaux (Rappel)
– L’échappement
• Permet d’échapper au sens donné aux caractères spéciaux par
l’interpréteur.
• Redonne leur sens littérale aux caractères spéciaux.
– Exemple
• Taper un nom de répertoire contenant un espace
user@MyPc : ~$ cd Mes Documents
-bash : cd : Mes : No such file or directory
user@MyPc : ~$
Programmation Shell
Échapper à l’interprétation
– Plusieurs modes d’échappement
– Fonctionnement
• Ponctuel : Le caractère qui suit le Back Slash (\) échappe à l’interprétation
(reprend son sens littérale).
• Complet : Tous les caractères compris entre les Guillemets Doubles
échappent à l’interprétation (reprennent leur sens littérale).
• Partiel : Tous les caractères compris entre les Guillemets Doubles
échappent à l’interprétation (reprennent leur sens littérale), sauf le
caractère $. Du coup, les noms de variables sont interprètés et remplacé
par leur valeur.
11
Programmation Shell
Échapper à l’interprétation
– Exemples d’échappement Ponctuel
user@MyPc : ~$ PLANETE=Terre
user@MyPc : ~$ echo $PLANETE # $PLANETE
Terre
user@MyPc : ~$ echo \$PLANETE \# $PLANETE
$PLANETE # Terre
– Exemples d’échappement Partiel et Complet
user@MyPc : ~$ PLANETE=Terre
user@MyPc : ~$ echo "$PLANETE # $PLANETE"
Terre # Terre
user@MyPc : ~$ echo ‘$PLANETE \# $PLANETE’
$PLANETE \# $PLANETE
Programmation Shell
Les calculs arithmétiques
– Bash un langage orienté sur le traitement des chaînes de
caractères
– Même si ce langage n’est pas fait pour effectuer des
opérations de calcul arithmétique il propose
des fonctionnalités de base permettant d’effectuer des
calculs simples tels que les additions, soustractions,
multiplications et divisions.
• utiliser $(()) ou expr
– Syntaxe
$(( expression_arithmétique ))
12
Programmation Shell
Les calculs arithmétiques
– Exemple :
user@MyPc : ~$ somme=$(( 4 + 2 ))
user@MyPc : ~$ echo $Somme
6
user@MyPc : ~$echo $(( 6 - 3 ))
3
user@MyPc : ~$ echo $(( 4 * 3 ))
12
user@MyPc : ~$ echo $(( 5 / 3 ))
1
user@MyPc : ~$
Programmation Shell
Les calculs arithmétiques
– La commande expr : permet d’évaluer des expressions
contenant des opérateurs arithmétiques ou logiques ou
portant sur des chaînes de caractères.
– La commande expr est principalement utilisée pour
effectuer des calculs sur des variables du type expr ${var1}
+ ${var2} que l’on peut ensuite affecter à une autre
variable via une substitution de commande du
type var =$(expr ${var1} + ${var2}).
13
Programmation Shell
La commande expr : opérateurs arithmétiques
Exemple
user@MyPc : ~$ expr 3 \* 2
6
user@MyPc : ~$ expr 13 % 5
3
user@MyPc : ~$a=3
user@MyPc : ~$ a=$(expr ${a} \* 2)
user@MyPc : ~$ echo $a
6
user@MyPc : ~$
14
