3IIR

Système d’exploitation (UNIX)

4ème partie

Professeur: IOUNOUSSE Jawad

 Exercice 5

1- Faites un programme qui permet de calculer et d'afficher la factorielle d'un

nombre donné en paramètre:
n ! = 1 × 2 × ... × (n−1) × n par convention 0 ! = 1
2- Changez le script de façon à donner le nombre par demande de saisie en cas
d’absence de paramètres.
3- Ajoutez dans le script le calcul qui élève le nombre (en paramètre ou saisi) à sa
propre puissance:
n n avec 0 0 = 1

Donnez les versions du script utilisant les boucles for, while et until.
Exercice 5 (Correction)
#!/bin/bash
if [ $# -eq 0 ]
then
echo "Saisir un nombre:"
read n
else
n=$1
fi
p=1
m=n
fct=1
for (( i=0 ; i<$n ; i++ ))
do
((p=$p*$n))
((fct=$fct*$m))
((m=$m-1))
done
echo "La puissance: $n^$n = $p"
echo "La factorielle: !$n = $fct"
 Exercice 6

1- Ecrivez un programme qui permet d’afficher un triangle isocèle formé d'étoiles de

N lignes (N est fourni au clavier) exemple:

Nombre de lignes : 8
*
***
*****
*******
*********
***********
*************
***************
Exercice 6 (Correction)
#!/bin/bash
if [ $# -eq 0 ]
then
echo "Saisir un nombre de lignes:"
read lgn
else
lgn=$1
fi
for (( l=0 ; l<$lgn ; l++ ))
do
((esp=$lgn-$l-1))
for (( i=0 ; i<$esp ; i++ ))
do
echo –e " \c"
done
for (( i=0 ; i<2*$l+1 ; i++ ))
do
echo –e "*\c"
done
echo –e "\n"
done
Programmation shell scripts (2)
 Les Tableaux
Le Bash gère également les variables « tableaux ». il est possible d'utiliser des tableaux à 1
dimension. Les éléments du tableau commencent toujours à l'indice 0.

 La déclaration des tableaux:

Il existe de nombreuses façons de déclarer un tableau dans un script Shell, qui sont
décrites ci-dessous :

- Déclaration indirecte: NOMTAB[INDICE]=valeur

- Déclaration explicite: declare -a NOMTAB
- Déclaration classique: NOMTAB=(val val2 .... valN)

 L’affichage des tableaux:

echo ${NOMTAB[INDICE]}
 Les Tableaux
Exemple:

#!/bin/bash

Villes=(Meknes Paris Lille Marrakech Rabat)

echo "Tous les éléments ${Villes[*]} "

echo "Le premier élément : ${Villes[0]} "
echo "Le premier élément : ${Villes} "

# ajouter un élément

Villes[5]=Lyon

echo "Tous les éléments ${Villes[@]} "

 Les Tableaux
 La suppression d’un élément du tableau:
Pour supprimer un élément du tableau ou supprimer un tableau, utilisez la
commande intégrée unset avec le nom du tableau et le numéro d'indice de l'élément
ou sa clé. Par exemple:

#!/bin/bash

Villes=(Meknes Paris Lille Marrakech Rabat)

echo "Tous les éléments : ${Villes[*]} “

unset Villes[3]
echo "Tous les éléments : ${Villes[*]} "

unset Villes[*]
echo "Tous les éléments : ${Villes[*]} "
 Les Tableaux
 Le nombre d’éléments d’un tableau: echo ${#NOMTAB[*]}

 La longueur d’un élément d’un tableau: echo ${#NOMTAB[INDICE]}

 Opérations de chaînes sur des tableaux:

#!/bin/bash
tab=( un deux trois quatre cinqcinq )

echo ${tab[@]:0} Tous les éléments

echo ${tab[@]:1} Tous les éléments après element[0]
echo ${tab[@]:1:2} Seulement les 2 éléments après element[0]
echo ${tab[@]#q*e}
echo ${tab[@]%r*s}

echo ${tab[@]/cin/XYZ}
echo ${tab[@]//cin/YY}
echo ${tab[@]//ci/}
echo ${tab[@]/#in/XY}
echo ${tab[@]/%nq/ZZ}
 Annexe
 Extraction de sous-chaînes avec l’opérateur ${}:

$ var=ABCDEFGHIJKLMNOPQRSTUVWXYZ
● L’option “:” de l’opérateur ${} permet
$ echo ${var:5:2}
d’extraire une sous-chaîne d’une variable.
FG
- La syntaxe est: $ echo ${var:20}
${variable:debut:longueur} UVWXYZ
$ variable=AZERTYUIOPAZERTYUIOP
● L’option “#” permet de supprimer le plus $ echo ${variable#AZE}
court préfixe correspondant au motif qui RTYUIOPAZERTYUIOP
vient après # : $ echo ${variable#*T}
- syntaxe : ${variable#motif} YUIOPAZERTYUIOP
$ echo ${variable#*[MNOP]}
- L’expression ${variable##motif}
PAZERTYUIOP
sert à éliminer le plus long préfixe $ echo ${variable##*T}
correspondant au motif transmis. YUIOP
$ echo ${variable##*[MNOP]}
 Annexe
 Extraction de sous-chaînes avec l’opérateur ${}:

● Symétriquement, les expressions

${variable%motif} et ${variable%%motif} $ variable=AZERTYUIOPAZERTYUIOP
correspondent au contenu de la variable, $ echo ${variable%IOP*}
débarrassée respectivement, du plus court et du AZERTYUIOPAZERTYU
plus long suffixe correspondant au motif indiqué. $ echo ${variable%%IOP*}
AZERTYU
$ echo ${variable%[X-Z]*}
● ${variable/motif/remplacement} permet AZERTYUIOPAZERT
de remplacer la première occurrence du motif par
$ echo ${variable%%[X-Z]*}
la chaîne de remplacement.
A
● ${variable//motif/remplacement} permet
de remplacer toutes les occurrences du motif par
la chaîne de remplacement.
 Les Tableaux
 Boucle sur les éléments d’un tableau:
#!/bin/bash
Script qui affiche le contenu
CARS=(Renault Toyota BMW Tata) d’un tableau CARS
for car in "${CARS[@]}"
do
Le Shell transforme chaque élément du tableau
echo "Car: $car"
en chaîne et renverra ensuite l'ensemble de
done
toutes ces chaînes concaténées

#!/bin/bash
i=1 Script qui affiche le contenu d’un tableau
weekdays="Mon Tue Wed Thu Fri" (chaine de caractères contenant des
for day in $weekdays mots séparés) weekdays en utilisant un
do compteur i
echo "Weekday $((i++)): $day"
done
 Les Fonctions
Un programme long est plus complexe et plus difficile à concevoir, coder et maintenir.
Par conséquent, il serait utile que la fonctionnalité globale d'un script soit séparée en
sous-sections plus petites et logiques. Ces sous-sections sont appelées fonctions Shell.
En particulier, la fonction est très utile lorsque vous avez certaines tâches qui doivent
être exécutées plusieurs fois. Ainsi, plutôt que d'écrire le même code, encore et
encore, il est préférable de l'écrire une fois dans une fonction et d'appeler la fonction à
chaque fois selon les besoins.

 La définition d’une fonction:

Il existe deux syntaxes que vous pouvez utiliser pour créer des fonctions dans les
scripts Shell Bash, qui sont décrites ci-dessous :

function nomfct { Nomfct() {

commandes ou commandes
} }
 Les Fonctions
 L’ appel d’une fonction:
Pour utiliser une fonction dans votre script, spécifiez le nom de la fonction sur une
ligne, comme vous le feriez pour toute autre commande Shell :

#!/bin/bash

function test1 {
echo "La première fonction"
}

test2() {
echo "La deuxième fonction"
}

test1
test2
test1
 Les Fonctions
 Passage d'arguments: #!/bin/bash
somme() {
Vous pouvez fournir les arguments juste
a=$1;b=$2
après le nom de la fonction. Ces paramètres
(( s=a+b ))
seront représentés par $1, $2, $3, et ainsi de
echo "La somme $a + $b=$s"
suite.
}

somme 5 4
somme 14 3

 Valeur de retour de la fonction Bash : #!/bin/bash

En utilisant le mot clé return , la valeur function somme {
retournée est stockée dans la variable par a=$1;b=$2
défaut $? (( s=a+b ))
return $s
}

somme 8 7
echo "La somme 8+7=$?"
 Les Fonctions
 Définition de variables locales:
La commande typeset ou declare ou local permet de définir des variables locales à une
fonction. Exemple:

#!/bin/bash
function f1 {
local var1=0
echo "Dans f1 => var1 avant : $var1"
var1=100
echo "Dans f1 => var1 après : $var1"
echo "Dans f1 => var2 avant : $var2"
var2=200
echo "Dans f1 => var2 après : $var2"
}
var1=1;var2=2
echo "Dans script => var1 avant f1 : $var1"
echo "Dans script => var2 avant f1 : $var2"
f1
echo "Dans script => var1 après f1 : $var1"
echo "Dans script => var2 après f1 : $var2"
 Les Fonctions
 Imbrication de fonctions:
une fonction ne sera exécutable que lorsque l'interpréteur du Shell sera passé par le nom de
la fonction et seulement s'il passe par la partie du code contenant le nom. Exemples:
#!/bin/bash
echo "Début du script"
#La fonction n'est pas encore connue
fonction()
{
echo "Fonction"
}
#La fonction est maintenant connue et utilisable
echo "Suite du script"
fonction

#!/bin/bash
if test "$1" = "go"
then Si la condition n'a pas été vérifiée,
fonction(){ la fonction ne sera pas connue et
echo "Fonction" son appel provoquera une erreur
}
fi
fonction
 Les Fonctions
 Imbrication de fonctions:
une fonction ne sera exécutable que lorsque l'interpréteur du Shell sera passé par le nom de
la fonction et seulement s'il passe par la partie du code contenant le nom. Exemples:

#!/bin/bash
externe() {
echo "Fonction externe"
interne() {
echo "Fonction interne" Une fonction « interne » ne sera
} connue que si une autre fonction
} « externe » est appelée
interne
externe
interne
 Les Fonctions
 La trace de l’appel de fonction:
L'instruction « caller » donne des informations sur l'appelant de la fonction (n° de
ligne de l'appel, fonction appelante, nom du script):

#!/bin/bash
fct1() {
fct2
}
fct2() {
fct3
}
fct3() {
echo "fct3 caller 0"; caller 0 #(fct2)
echo "fct3 caller 1"; caller 1 #(fct1)
echo "fct3 caller 2"; caller 2 #(programme)
echo "fct3 caller 3"; caller 3 #(néant)
}
fct1
echo "main caller 0"; caller 0
 Les Fonctions
 Import d’un script dans un autre script:
L'instruction « source » permet d'importer un fichier à l'endroit où la commande
est exécutée:
somme.sh
#!/bin/bash
function somme { test.sh
a=$1;b=$2 #!/bin/bash
(( s=a+b )) source ./somme.sh
return $s somme 7 9
} echo $?
source ./produit.sh
produit.sh produit 7 7
#!/bin/bash echo $?
function produit {
a=$1;b=$2 Définition du chemin d’une source
(( p=a*b )) Dans l’exemple les 2 sources se
return $p trouvent dans le même dossier
}
 Exercice 7
 Tri à bulles:

Le tri à bulles ou tri par propagation consiste à comparer répétitivement les

éléments consécutifs d'un tableau, et à les permuter lorsqu'ils sont mal triés.
Exemple:

Tableau d’entrée: 11 8 3 6

Après 1ère itération: 8 3 6 11

Après 2ème itération: 3 6 8 11 Trié

- Ecrivez un script «tri.sh» qui permet de trier par ordre croissant les éléments
d’un tableau saisi en entrant le nombre d’éléments du tableau en premier.
 Exercice 8

Écrire un script «inverse.sh» permettant d‘inverser une variable (chaine de

caractères) saisie par lecture. Exemple:

Ecrivez qlq chose ?

EMSI
Sortie inversée: ISME

Essayez de créez une fonction inverse() dont l’attribut est la variable saisie est
qui permet une sortie inversée