3IIR

Système d’exploitation (UNIX)

2ème partie

Professeur: IOUNOUSSE Jawad

 Exercice 2
1. Affichez les Shells disponibles sur votre système.
2. Affichez votre Shell actuel.
3. Affichez votre Shell par défaut.
4. Basculez d’un Shell à un autre puis fermer chaque Shell ouvert.
5. Changez votre Shell par défaut.
6. Vérifiez la disponibilité des éditeurs de texte et familiarisez-vous avec l’un d’eux.
 Exercice 2 (correction)
1. Affichez les Shells disponibles sur votre système.
$ cat /etc/shells
2. Affichez votre Shell actuel.
$ echo $SHELL
3. Affichez votre Shell par défaut.
$ cat /etc/passwd
4. Basculez d’un Shell à un autre puis fermer chaque Shell ouvert.
Utilisez Ctrl + D pour basculer et exit pour fermer le shell actuel
5. Changez votre Shell par défaut.
$ chsh
6. Vérifiez la disponibilité des éditeurs de texte et familiarisez-vous avec l’un d’eux.
$ which vi
$ which vim
$ which nano
$ which gedit
Programmation shell scripts (1)
 Les variables
- Il est possible d'écrire dans un script des commentaires afin de faciliter la
compréhension du script. Les commentaires sont désignés à l'aide du caractère #.
# Ceci est un commentaire

En général, il y a deux types de variables dans un Shell:

 Les variables utilisateur:
Il est possible de définir des variables dites variables utilisateur qui vont
permettre de stocker des informations utiles durant l'exécution de scripts.
 Les variables d'environnement:
Ce sont des variables définies dans l’environnement Shell. Elles contiennent des
infos nécessaires au fonctionnement de l’interpréteur et des commandes lancées à
partir de celui-ci.
 Les variables des paramètres:
Comme toutes les commandes, vos scripts bash peuvent eux aussi accepter des
paramètres.
 Les variables Utilisateur
Une variable est une suite de caractères alphanumériques associée éventuellement à
une valeur.
 Nommage des variables:
- Le premier caractère doit être obligatoirement une lettre minuscule, majuscule ou un
tiret bas [a-zA-Z_]
- Les caractères suivants peuvent être des lettres en minuscule, majuscule, des chiffres
de 0 à 9 ou un tiret bas [a-zA-Z0-9_]
 Définition d'une variable:
- Assignation de variable: $ variable1=valeur1
- Consultation de variable par $variable1 ou ${variable1}
- Visualisation de toutes les variables définies par la commande:
( set -o posix ; set ) | less
- Destruction d’une variable par la commande: unset variable
- Protection d’une variable en écriture : readonly variable
- Liste des variables protégées en écriture : readonly
 Les variables Utilisateur
 Commande echo pour l’affichage:
Voyons la différence entre l’utilisation des quotes, des doubles quotes et des back quotes:

script.sh Ligne shebang

Créons un fichier « script.sh » : #!/bin/bash

$ touch script.sh msg= 'pwd'

$ chmod +x script.sh echo 'Le message 1 est : $msg'
echo "Le message 2 est : $msg"
On l’exécute par:
$ ./script.sh msg= `pwd`
Ou $ bash script.sh echo "Le message 3 est : $msg"
Ou $ source script.sh
Résultat
Le message 1 est : $msg
Le message 2 est : pwd
Le message 3 est : /home/user
 Les variables Utilisateur
 Commande printf pour l’affichage formaté:

Permet d’afficher des Affichage d'une chaine (string) sur 20 positions avec
%20s cadrage à droite
données formatées.
Cette commande est Affichage d'une chaine (string) sur 20 positions avec
%-20s cadrage à gauche
une sorte de “echo”
nettement amélioré Affichage d'un entier (décimal) sur 3 positions avec
%3d cadrage à droite
proposant des formats
pour afficher les Affichage d'un entier (décimal) sur 3 positions avec
%03d cadrage à droite et complété avec des 0 à gauche
nombres réels.
Les programmeurs C Affichage d'un entier (décimal) sur 3 positions avec
%-3d cadrage à gauche
reconnaîtront une
implémentation en %+3d
Affichage d'un entier (décimal) sur 3 positions avec
ligne de commande de cadrage à droite et affichage systématique du signe
la célèbre fonction de Affichage d'un nombre flottant sur 10 positions dont 2
%10.2f
la bibliothèque stdio.h décimales
Exemples de formats Affichage d'un nombre flottant sur 10 positions dont 2
(voir tableau) : %+010.2f décimales, complété par des 0 à gauche, avec cadrage à
droite et affichage systématique du signe
 Les variables Utilisateur
 Commande read pour la saisie ou lecture:

$ read v
$ echo $v
Quelques options:
-p : pour afficher un message
$ read –p "donner v: " v
-s : pour masquer la saisie
$ read –p "donner v: " –s v
-n : pour limiter le nombre de caractères
$ read –p "donner v: " –n 5 v
-t : pour limiter le temps de saisie
$ read –p "donner v: " –t 2 v
 Les variables Utilisateur
$ MOT=volume
 Précaution sur les variables:
$ echo $MOT42
Mieux vaut utiliser ${nom_variable} que
$nom_variable : $ echo ${MOT}42
volume42
$
 Substitution de variables:
utilise la valeur de la variable si elle est positionnée et non nulle,
${variable:-valeur}
sinon utilise la valeur donnée.
utilise la valeur de la variable si elle est positionnée et est non
${variable:=valeur} nulle, sinon affecte la valeur à la variable et utilise la valeur
donnée.
utilise la valeur de la variable si elle est positionnée et non nulle,
${variable:?valeur} sinon écrit la valeur sur l’erreur standard et fait un exit avec un
statut non nul
utilise une chaîne vide si la variable est positionnée et non nulle,
${variable:+valeur}
sinon, utilise la valeur.
${#variable} utilise la taille de la valeur de la variable
 Les variables Utilisateur
 Substitution de variables: (Exemples)
$ jour=mardi
$ echo "Nous sommes : ${jour:-dimanche}"
Nous sommes : mardi
$ unset jour
$ echo "Nous sommes : ${jour:-dimanche}"
${variable:-valeur}
Nous sommes : dimanche
$ echo $jour
$

$ jour=mardi
$ echo "Nous sommes : ${jour:=dimanche}"
Nous sommes : mardi
$ echo $jour
mardi
$ unset jour ${variable:=valeur}
$ echo "Nous sommes : ${jour:=dimanche}"
Nous sommes : dimanche
$ echo $jour
dimanche
$
 Les variables Utilisateur
 Substitution de variables: (Exemples)
$ bool=1
$ echo "Si bool=1 alors j'affiche :
${bool:+true}"
Si bool=1 alors j'affiche : true
$ unset bool ${variable:+valeur}
$ echo "Si bool=1 alors j'affiche :
${bool:+true}"
Si bool=1 alors j'affiche :
$

$ nombre=56
$ echo ${nombre:?"nombre indefini"}
56
$ unset nombre
$ echo ${nombre:?"nombre indefini"} ${variable:?message}
-bash: nombre: nombre indefini

$ echo ${nombre:?} #message par défaut

-bash: nombre : parametre vide ou non defini
$
 Les variables paramètres
Comme toutes les commandes, vos scripts bash peuvent eux aussi accepter des
paramètres. Exemple:
./variables.sh param1 param2 param3
Pour récupérer ces paramètres dans notre script on utilise ce qu’on appelle
variables paramètres (variables positionnelles):

Syntaxe Commande

$0 Nom du script Shell

$1, $2, .. Le premier, deuxième, ... paramètre
$# Le nombre de paramètres passés au script Shell
$@ Tous les paramètres passés au script Shell
$* Tous les paramètres passés au script Shell sous la forme de mots séparés
 Les variables paramètres
Exemple : « script2.sh » contient le script suivant:
script2.sh
#!/bin/bash
# Ce programme affiche les parametres de la ligne de commande
echo "* Le nom du programme est : $0"
echo "* Le troisieme parametre est : $3"
echo "* Le nombre de parametre est : $#"
echo "* Tous les parametres (mots individuels) : $*"
echo "* Tous les parametres : $@"
exit 0

$ ./script2.sh un "deux" "trois quatre" cinq

* Le nom du programme est : ./script2.sh
* Le troisieme parametre est : trois quatre
* Le nombre de parametres est : 4
* Tous les parametres (mots individuels) : un deux trois
quatre cinq
* Tous les parametres : un deux trois quatre cinq
$
 Les variables paramètres
Exemple : « script3.sh » contient le script suivant:
script3.sh
#!/bin/bash
echo $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12
exit 0
$ ./script3.sh un deux trois quatre cinq six sept huit neuf dix onze
douze
un deux trois quatre cinq six sept huit neuf un0 un1 un2
$

script3.sh
#!/bin/bash
echo $1 $2 $3 $4 $5 $6 $7 $8 $9 ${10} ${11} ${12}
exit 0
$ ./script3.sh un deux trois quatre cinq six sept huit neuf dix onze
douze
un deux trois quatre cinq six sept huit neuf dix onze douze
$
 Les variables d’environnement
Variables d’environnement courantes utilisées par de nombreuses commandes (ainsi
que par le Shell) :

HOME Le répertoire « maison » de l’utilisateur

USER Le login utilisateur
SHELL Le Shell utilisateur
La liste des chemins dans laquelle le Shell cherchera les commandes
PATH
exécutables qui seront tapés sans indication de chemin
TERM Le type de terminal
PS1 L’invite (prompt)
PWD Le répertoire courant
LANG Le langage utilisé
LOGNAME Le nom de l'utilisateur connecté

L’affichage des variables d’environnement se fait par la commande env

 Autres variables et typage
$RANDOM Nombre aléatoire entre 0 et 32 767
$$ Numéro du processus courant
$! Numéro du dernier processus lancé en arrière-plan
$? Statut (état final) de la dernière commande

 Typage des variables:

Les Shells évolués comme bash permettent de restreindre les propriétés des variables
et correspondent à une certaine forme de typage « simpliste ». Or, pour déclarer un type:
typeset -a var : la variable sera traitée comme un tableau.
typeset -i var : la variable sera traitée comme un entier et peut être incluse dans des
opérations arithmétiques.
typeset -r var : la variable sera mise en « lecture seule » (équivalent à readonly ).
typeset -x var : la variable sera exportée automatiquement dans les processus fils
(équivalent à export ).

En bash, on peut utiliser la commande declare à la place de typeset.

 La variable $PATH
Cette variable contient une liste de répertoire dans lesquels le Shell recherche toutes
les commandes qui sont exécutées.
Si une commande est exécutée et qu'elle ne se trouve dans aucun des répertoires
indiqués dans la variable PATH, une erreur sera retournée en indiquant que la commande
est introuvable. Si l'on souhaite exécuter une commande qui se trouve dans un répertoire
non indiqué dans la variable PATH, il suffit tout simplement de modifier le contenu de
cette variable. Exemple : Créons une commande EMSI dans un répertoire non inclus dans
la variable PATH qui affiche un simple message « WELCOME »

Créons un répertoire « Projet » dans lequel on crée « EMSI » :

$ mkdir Projet EMSI
$ cd Projet #!/bin/bash
$ touch EMSI
$ chmod 755 EMSI echo "WELCOME !"

On modifie le contenu de la variable en ajoutant une ligne au fichier ~/.bashrc :

PATH=$PATH:/leRepertoireDeMaCommande
Ou par la commande:
export PATH=$PATH:/leRepertoireDeMaCommande
 Visibilité des variables
Lorsqu'un script Shell est lancé depuis l'environnement d'un utilisateur, ce script commence son
exécution mais ne connaît, par défaut, aucune des variables de l'environnement qui lui a donné
naissance (environnement « père »). Pour qu'un processus « père » puisse faire connaître une
variable à un processus « fils », il doit l'exporter avec la commande « export var ». Exemple:
Créons un script « prog.sh » affichant et prog.sh
modifiant une variable qu'il n'a pas créée: #!/bin/bash
$ touch prog.sh echo "Contenu de var : $var"
$ chmod a+x prog.sh var=Salut
Résultat echo "Contenu de var : $var"

Sans exportation: Avec exportation:

$ var=Bonjour $ export var=Bonjour
$ echo $var $ echo $var
Bonjour Bonjour
$ ./prog.sh $ ./prog.sh
Contenu de var : Contenu de var : Bonjour
Contenu de var : Salut Contenu de var : Salut
$ echo $var $ echo $var
Bonjour Bonjour
 Opérations logiques
La commande test permet de faire des tests sur des fichiers, des chaines de caractères et des
nombres. Elle renvoie le code retour 0 (vrai) ou 1 (faux) qu'il est possible de consulter en
affichant la valeur de $? . Il existe 2 syntaxes pour utiliser la commande test:
$ test expression ou $ [ expression ]
 Tests sur les nombres:

Expression Code de retour

INT1 -eq INT2 Vrai si INT1 est égal à INT2 (=)
INT1 -ge INT2 Vrai si INT1 est supérieur ou égal à INT2 (>=)
INT1 -gt INT2 Vrai si INT1 est supérieur à INT2 (>)
INT1 -le INT2 Vrai si INT1 est inférieur ou égal à INT2 (<=)
INT1 -lt INT2 Vrai si INT1 est inférieur à INT2 (<)
INT1 -ne INT2 Vrai si INT1 est différent de INT2 (!=)
Exemple: $ [ $B -eq $C ]
$ A=1 $ [ $C -ge $A ]
$ B=2 $ echo $? $ echo $?
$ C=2 0 0
 Opérations logiques
 Tests sur les fichiers:
Expression Code de retour
-b Fichier Vrai s’il existe et est du type spécial bloc
-c Fichier Vrai s'il existe et est du type spécial caractère
-d Fichier Vrai s'il existe et est du type répertoire
-e Fichier Vrai s'il existe
-f Fichier Vrai s'il existe et est du type ordinaire
-G Fichier Vrai s'il existe et si l’user appartient au groupe propriétaire du fichier
-h Fichier Vrai s'il existe et est du type lien symbolique
-L Fichier Vrai s'il existe et est du type lien symbolique (idem -h)
-O Fichier Vrai s'il existe et si l'utilisateur est le propriétaire du fichier
-r Fichier Vrai s'il existe et est accessible en lecture
-s Fichier Vrai s'il existe et n'est pas vide
-S Fichier Vrai s'il existe et est du type socket
-w Fichier Vrai s'il existe et est accessible en écriture
-x Fichier Vrai s'il existe et est exécutable
Fichier1 -ef Fichier2 Vrai si les fichiers ont le même lien physique
Fichier1 -nt Fichier2 Vrai si Fichier1 est plus récent que Fichier2
Fichier1 -ot Fichier2 Vrai si Fichier1 est plus ancien que Fichier2
 Opérations logiques
 Tests sur les chaines de caractères:
Expression Code de retour
-n String Vrai si la longueur de la chaine n'est pas égale à 0
-z String Vrai si la longueur de la chaine est égale à 0
String1 = String2 Vrai si les 2 chaines sont égales
String1 != String2 Vrai si les 2 chaines sont différentes
String Vrai si la chaine n'est pas vide (idem -n)
 Les opérateurs logiques:
Exemples:
Opérateur Signification $ [ ! -d /etc/group ]
! Négation $ echo $? Le fichier /etc/group
0 n'est pas un répertoire
-a ET
$ [ -f script.sh -a -x script.sh ]
-o OU
$ echo $?
[[ ]] est une version améliorée de la 0 script.sh existe et exécutable
commande test. Tous les opérateurs $ [[ -d script.sh || -x script.sh ]]
utilisés restent valables à l'exception des $ echo $?
opérateurs logiques -a et -o 0 script.sh n'est pas un répertoire mais exécutable
respectivement remplacés par && et ||.
 Opérations arithmétiques
 La commande expr:
Syntaxe : expr $nbr1 operateur $nbr2
expr $chaine : expression_reguliere

Opérateurs arithmétiques
$nb1 + $nb2 Addition
$nb1 - $nb2 Soustraction
$nb1 \* $nb2 Multiplication
$nb1 / $nb2 Division
$nb1 % $nb2 Modulo
Opérateurs de comparaison
$nb1 \> $nb2 VRAI si $nb1 est strictement supérieur à $nb2
$nb1 \>= $nb2 VRAI si $nb1 est supérieur ou égal à $nb2
$nb1 \< $nb2 VRAI si $nb1 est strictement inférieur à $nb2
$nb1 \<= $nb2 VRAI si $nb1 est inférieur ou égal à $nb2
$nb1 = $nb2 VRAI si $nb1 est égal à $nb2
$nb1 != $nb2 VRAI si $nb1 est différent de $nb2
 Opérations arithmétiques
 La commande expr:
Syntaxe : expr $nbr1 operateur $nbr2
expr $chaine : expression_reguliere

Opérateurs logiques
$chaine1 \& $chaine2 VRAI si les 2 chaines sont vraies
$chaine1 \| $chaine2 VRAI si l'une des 2 chaines est vraie
Opérateurs divers
-$nb1 Opposé de $nb1
\( expression \) Regroupement
$chaine : expression_reguliere Compare la chaine avec l'expression régulière
Exemple: $ nb=3
$ expr $nb + 5 $ nb=10
8 $ expr $nb % 3
$ expr $nb \* 6 1
18 $ expr $nb - -5
$ expr $nb / 2 15
1
 Opérations arithmétiques
 La commande expr:
Pour récupérer le résultat dans une $ nb2=`expr $nb - 2`
$ echo $nb2
variable: (nb=10)
8

Ajouter un regroupement pour une $ nb=5

$ nb2=`expr $nb \* 3 + 4`
priorité d’exécution:
$ echo $nb2
19
$ nb2=`expr $nb \* \( 3 + 4 \)`
$ echo $nb2
35

Résultat d'une comparaison VS
valeur du code de retour :
$ nb=2
$ expr $nb \>= 1
1 Résultat de la comparaison
$ echo $?
0 Résultat du code de retour
$ expr $nb \>= 3
0 Résultat de la comparaison
$ echo $?
1 Résultat du code de retour
 Opérations arithmétiques
 La commande (( )):
La commande (( )) dispose de nombreux avantages par rapport à la commande expr:
 Opérateurs supplémentaires.
 Les variables n'ont pas besoin d'être préfixées par le symbole $.
 Les caractères spéciaux du Shell n'ont pas besoin d'être protégés par des antislashs.
 Les affectations se font dans la commande. Alors son exécution est plus rapide.
Opérateurs arithmétiques
nb1 + nb2 Addition
nb1 - nb2 Soustraction
nb1 * nb2 Multiplication
nb1 / nb2 Division
nb1 % nb2 Modulo
Opérateurs de comparaison
nb1 > nb2 VRAI si $nb1 est strictement supérieur à $nb2
nb1 >= nb2 VRAI si $nb1 est supérieur ou égal à $nb2
nb1 < nb2 VRAI si $nb1 est strictement inférieur à $nb2
nb1 <= nb2 VRAI si $nb1 est inférieur ou égal à $nb2
nb1 = nb2 VRAI si $nb1 est égal à $nb2
nb1 != nb2 VRAI si $nb1 est différent de $nb2
 Opérations arithmétiques
 La commande (( )):
Opérateurs travaillant sur les bits
~nbr1 Complément à 2
nbr1 >> nbr2 Décalage sur nbr1 de nbr2 bits à droite
nbr1 << nbr2 Décalage sur nbr1 de nbr2 bits à gauche
nbr1 & nbr2 ET bit à bit
nbr1 | nbr2 OU bit à bit
nbr1 ^ nbr2 OU exclusif bit à bit
Opérateurs logiques
!expression Inverse la valeur de vérité de expression
&& ET
|| OU
Opérateurs divers
-nbr1 Opposé de nbr1
nbr1 = expression Assignement
(expression) Regroupement
binop représente l'un des opérateurs suivants : +, -, /, *, %,
nbr1 binop= nbr2
>>, <<, &, |, ^. Equivalent à nbr1 = nbr1 binop nbr2
 Opérations arithmétiques
 La commande (( )):

Exemple: $ nbr1=10
$ ((nbr1=nbr1+10))
$ echo $nbr1
20
$ nbr1=10
$ ((nbr1+=10))
$ echo $nbr1
20

$ nbr1=5
$ nbr2=6
$ ((nbr1>nbr2))
$ echo $?
1 Code retour 1 (faux) car nbr1 n'est pas supérieur à nbr2
$ ((nbr1<nbr2))
$ echo $?
0 Code retour 0 (vrai) car nbr1 est inférieur à nbr2
 Opérations arithmétiques
 La commande let
La commande let est équivalente à (( )) . Exemples:
$ nbr1=5
$ let "nbr1=nbr1*3"
$ echo $nbr1
15

Calcul du modulo et affectation:

$ nbr1=5
$ let nbr2=nbr1%2
$ echo $nbr1
5
$ echo $nbr2
1

 Le calculateur standard sous UNIX: bc

L’outil bc peut prendre en entrée standard des opérations.
$ nbr1=5
$ echo "$nbr1*0.65" | bc –l
 Exercice 3
Modifiez « script.sh » pour permettre de:
a) Afficher un simple message : Vous êtes dans le programme: Nom_du_fichier
b) Demander la saisie de deux nombres nb1 et nb2 consécutivement avec un simple
message de demande.
c) Afficher le résultat des opérations entre nb1 et nb2 avec un message:
- Somme
- Soustraction
- Division
- Multiplication
- Modulo
d) Utiliser maintenant les variables paramètres de « script.sh » pour la saisie des
nombres et refaire c)
e) Vérifier les expressions suivantes en donnant leur code de retour:
- nb1 < nb2
- nb1 = nb2
f) Ajouter 2 autres variables paramètres et vérifier les expressions suivantes en donnant
leur code de retour:
1. nb1 - nb2 > nb4 - nb3 3. nb1 ≥ nb2 or nb4 ≤ nb3
2. nb1 = nb4 and nb2 ≠ nb3
 Exercice 4
1) Identifiez les fichiers d’initialisation de sessions propres à votre compte.
2) Créez un alias permanent pour remplacer la commande “ls -la” par “ls”.