Cours Unix Utilisateur

Les scripts Shell

Voir aussi le cours de J. Gourdin (fac de Créteil)

Un script shell ou fichier de commandes est un fichier texte qui continet des commandes du shell, qui seront éxécutées de manière non intéractive.
La toute première ligne du fichier doit contenir le nom de l’interpréteur à utiliser (cela est valable pour tous les langages de script). Cette ligne doit commencer par #! (SHEBANG!) suivi de l’exécutable à utiliser pour lancer le shell.
Pour un script bash , on aura donc en début de fichier en général :

#! /bin/bash
# commentaire de debut du script
commandes bash…

Pour exécuter un script on l’appelle simplement par son nom. ..mais il y a 2 conditions à satisfaire :

• le script doit être ‘exécutable’ par celui qui le lance
• le script doit être dans le chemin d’exécution ou son chemin spécifié complètement

Voici un exemple de création et d’exécution de script simple :

$> vi nettoie_tmp.sh
#! /bin/bash
cd /home/dd/tmp
rm -R *
echo “nettoyage fini !”
<esc>:wq

note : si le répertoire courant de l’utilisateur est dans le PATH il est inutile de spécifier le ‘./’ . Voir environnement personnalisé pour plus d’infos.

et sans supplément de prix en voici un autre encore plus simple:

#!/bin/bash
# script bonjour.sh
echo Bonjour $USER
echo “Aujourdhui nous sommes le ” ; date
echo “et il va falloir se mettre au Shell !!”

Entrées-sorties

Pour afficher on utilise la commande ‘echo’ …de la facon suivante :

echo ” un texte quelconque entre guillemets”

note : le texte sera suivi automatiquement par un saut de ligne.

On peut utiliser des caractères spéciaux habituels, qui seront interprétés seulement avec l’option -e.
Rappel des caractères spéciaux :

• \n (saut ligne),
• \b retour arrière),
• \t (tabulation),
• \a (alarme),
• \c (fin sans saut de ligne)

un exemple

echo “Bonjour \nMesdames !”
echo -e “Bonjour \nMesdames !”
echo -e “Bonjour \nMesdames, \Mesdemoiselles et Messieurs \c”

Pour lire une valeur au clavier et la ranger dans une variable, on utilise ‘read’.
Et ce de la facon suivante :

read var1 var2 …

Voici un exemple

echo “Saisissez votre civilité”
read civil
echo “Saisissez a la suite vos prénom et votre nom”
read prenom nom
echo “Bonjour $civil $prenom $nom”

Comment afficher le résultat d’une commande ?

echo ls ou echo “ls” donnent le même résultat…ils affichent le mot ‘ls’.
On utilisera le caractère magique anticote ou cote inversée (en général sous la touche ’7′ d’un clavier Francais) pour encadrer la commande :

exercice : écrire un script qui utilise ‘echo’ et qui écrit ‘ls’, fait une pause en attendant une saisie utilisateur et execute un ls (toujours dans un ‘echo’)

Variables et paramètres d’un script

Rappel : les variables du shell sont définis par leur nom, initialisé par un ‘=’ (sans espace) et référencées par un caratère ‘$’ qui permet d’évaluer… leur valeur. Il en va de même pour les scripts.

X=12
c=”Salut les gars”
echo $X
echo $c

note : lorsque le nom de la variable peut être ambigu, on utilise les accolades pour lever l’ambiguité :

x=a
y=b
xy=cd
echo $xy
cd
echo ${x}y
ay
echo ${xy}
cd

Il existe un certain nombre de variables prédéfinies plus spécialement utiles aux scripts. Voici les principales :

$0 : le nom du script
$1 à $9 : les paramètres éventuels passés au script
$# : le nombre de paramètres passés au script
$* : la liste des arguments à partir de $1
$? : la sortie de la dernière (0 = succès)
$$ : le n° PID du processus courant
$! : le n° PID du processus fils

Voici qq exemples :

$> vi compte.sh
# compte les fichiers d’un certain type dans le répertoire cible
# compte.sh utilise 2 parametres
# $1 : le répertoire cible
# $2 : le type d’extension de fichiers recherchés
# on se place dans le répertoire
cd $1
# et on compte les fichiers !
ls *.$2 |wc
<esc>:wx
$> ./compte.sh /var/log log
13 13 150

$> cd /
$> echo $?
0
$> touch essai
Can’t touch ‘essai’ : permission denied
$> echo $?
1

Note : au dela de 10 paramètres on peut utiliser la commande ‘shift’ . Après un ‘shift’ $1 prend la valeur de $2, …, $9 prend la valeur de $10

exercice : faire la somme des neuvieme et dixieme parametre d’un script.
(truc : utiliser ‘expr’ pour faire effectivement le calcul)

Les fonctions

Pour structurer et réutiliser son code comme dans tout langage, on peut utiliser des fonctions.
On déclare la fonction avec le mot réservé ‘function’ et on l’exécute en référencant son nom. Les paramètres éventuels sont passés sans parenthèses.

# def fonction
function nom_fonction
{
instructions
}
# appel fonction sans parametre
nom_fonction
# appel fontion avec paramètres
nom_fonction paramètre

Les fonctions retournent un statut d’exécutation (OK ou HS) respectivement 0 ou !=0. Il est accessible par ‘$?’

Les fonction peuvent retourner une valeur numérique (<255) grace au mot réservé ‘return’
Des exemples :

# test fonctions
#
function titre {
# il n’y a a pas de parametre…
echo “un titre quelconque”
}
function affiche
{
# $1 est le 1er parametre de la fonction
echo $1
}
# appel sans param
titre
# appel et passage par valeur
affiche bonjour
politesse=”mon cher “
# on met des “” pour prendre les 2 mots de la chaine…
# passage par adresse
affiche “$politesse”
# $1 est le 1er parametre du Shell (s’il y en a…)
echo $1

La Structure if

permet d’orienter le contrôle du programme suivant la valeur logique d’une expression. C’est une alternative. Au lieu de continuer à s’exécuter séquentiellement, si l’expression est vraie on va exécuter telle partie du progarmme, sionon telle autre.
Un if a la forme suivante :

if instructions
then
#1er bloc d’instructions
else
#2nd bloc d’instructions
fi

Le nombre d’alternatives n’est pas limité

Alternatives imbriquées :

if condition1
then instruction1
instruction2
……….
elif condition2
then instruction3
instruction4
……..
elif condition3
then instruction5
instruction6
……..
fi

then elif else doivent figurer sur une nouvelle ligne (ou être précédés de ‘;’)

Les conditions Logiques

testées soit par la commande ‘test’ soit par placement de l’expression entre [] :

test expression

[ expression ] # attention aux ‘espaces’ !!!!!

Nous allons passer en revue les différents opérateurs utilisables dans les conditions logiques. Ils en existe pour chaque type d’opérande (chaines de caractères, entiers, fichiers)

• tests de chaines

s1 = s2 ( égalité ? )
s1 != s2 ( s1 différente de s2 ? )
s1 (chaine s1 non vide ? )
-z s1 (chaine s1 vide ? )

• test d’Entiers

n1 -eq n2 ( ‘eq’ veut dire ‘equals’ on teste  donc si n1==n2)
n1 -ne n2 ( ‘ne’ veut dire ‘not equals’ on teste  donc si n1 != n2)
n1 -gt n2  ‘gt’ veut dire ‘greater than ou plus grand que ‘ on teste  donc si n1 > n2)
n1 -lt n2 ( ‘lt’ veut dire ‘less than’ ou ‘plus petit que’  on teste  donc si  n1 < n2)
n1 -ge n2 ( ‘ge’ veut dire ‘greater or equal’  ou ‘supérieur ou égal’ on teste  donc si  n1 >= n2)
n1 -le n2 ( ‘le’ veut dire ‘less or equal’ ou ‘inférieur ou égal’ on teste  donc si n1 <= n2)

• test de Fichiers

-r fich (‘r’ = ‘readable’ , fichier fich lisible ? )
-w fich (‘w’ = ‘writable’ , fichier fich modifiable ? )
-x fich (‘x’ = ‘eXecutable’ , fichier fich exécutable ? )
-f fich (‘f’ = ‘file’ : fich fichier ordinaire ? )
-d fich (‘d’ = ‘directory’ , fich est un répertoire ? )
-s fich (fich fichier non vide ? )

• Combinaisons logiques d’expression

expr1 -o expr2 (expr1 ou expr2)
expr1 -a expr2 (expr1 et expr2)
§ expression (négation de expr1)

Quelques exemples

# si la note est > 15…
if [ $note -gt 15 ]
then echo “Très bien !”
fi

# Avant d’exécuter un script, on peut s’assurer qu’il existe
if [ -f ~/.bashrc ]
then
. /.bashrc
fi

La Structure case

permet de comparer une expression plusieurs autres expressions constantes ou comportant des caractères spéciaux pour le shell (?, *, []) :

case $variable in
valeur1)
#1er bloc d’instructions
;;
valeur2)
#2ème bloc d’instructions
;;
valeur3)
#3ème bloc d’instructions
;;
*)
#Traitement des autres valeurs
;;
esac

Une pseudo clause “default“ est possible en donnant à la dernière forme la valeur ‘*’

La Boucle for

: itérer l’exécution d’un groupe de commandes avec un paramètre prenant ses valeurs successives dans une liste

for variable in liste_de_valeurs
do
# Traitement à répéter
done

do et done doivent être sur une nouvelle ligne (ou précédés d’un ‘;’)

$> une simple boucle
$> # on ne fait pas un script…
$> # on enchaine les commandes
$> for i in 1 2 3 4
> do
> echo $i
> done
1
2
3
4
$>

for util in /home/*
do
echo “bonjour utilisateur $util”
done

La Boucle while

permet de boucler tant qu’une expression renvoie la valeur Vrai :

while instructions
do
# instructions à répéter
done

1 do et done doivent être sur une nouvelle ligne (ou précédés de ‘;’)

while who | grep -s stage3
do
echo $G
sleep 300
done &

Interruptions

Il est possible d’interrompre plus ou moins violemment (en continuant ou pas le programme ou le shell…)

break : interrompt l’exécution et reprend l’instruction qui suit la boucle
return : interrompt l’exécution et sort du script en cours
exit : interrompt l’exécution et retourne au niveau du SHELL appelant