Responsable du cours: Mohamed

Ben Halima
Systèmes d’exploitation Enseignant :Iskandar Keskes
évolués Filière: T-MIM & P-IITMW
Année universitaire:
2007 -2008

TP N° 07
Les scripts Shell
Objectif :
A l’issue du TP l’étudiant devra :
• Etre capable d’éditer un fichier script utilisant des variables système et des variables
définies par l’utilisateur.
• Etre capable de calculer et de manipuler des variables chaîne de caractères ou
numériques.
• Etre capable d’utiliser des valeurs de retour d’appel de commandes.
• Etre capable d’enchaîner des commandes.
• Etre capable d’utiliser des structuras de contrôle dans les fichiers script.

1. Les scripts Shell :

1.1 Introduction :

Un Shell-script (ou script Shell) est un fichier texte simple. Il peut donc être écrit avec un
éditeur de texte. 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
#! suivi de l'exécutable à utiliser. Pour un Shell-script bash, on aura donc en début le
fichier par : #!/bin/bash

Un Shell est constitué par l’association d’un interpréteur de commandes et de commandes

(instructions) pouvant être passées sur la ligne de commande ou regroupées dans des
fichiers scripts.

Les instructions sont constituées par :

- des variables.
- des opérations (applicables aux variables).
- des structures de contrôle.
Exemple :
Editez le script nommé “fichier1.sh” avec Emacs (ou autre éditeur de texte) et contenant
les lignes suivantes :
# ! /bin/bash
# mon premier fichier script
pwd
ls -l
echo ceci est affiché
# fin de mon fichier script
Les commentaires sont sur des lignes débutant par #

La première ligne contient le chemin d’accès et le nom du Shell à utiliser pour ce fichier script.
(Il existe plusieurs Shell différents, qui n’utilisent pas la même syntaxe.)

1/18
 • Lancez ce script en saisissant son nom sur la ligne de commande. Que ce passe-t-
il ? Pourquoi ?
• Attribuez le droit d’exécution au propriétaire et lancer la commande.

Un script se termine lorsque la dernière ligne a été exécutée. On peut toutefois forcer sa
sortie avant en utilisant la commande exit. Le code de retour du script sera celui de la
dernière commande exécutée. Cela à moins de préciser une valeur numérique à la suite de
exit. C'est alors celle-ci qui sera renvoyée

Phases de travail du Shell lorsqu’une commande est passée :

Le Shell détermine Si la commande est une commande qu’il connaît (interne) ou non
(externe).
 interne  exécution
 externe  recherche du fichier dans les répertoires indiqués par la variable
d’environnement PATH.
Si le fichier n’est pas trouvé, affichage d’un message d’erreur.
Si le fichier est trouvé il faut déterminer si c’est un fichier binaire ou autre.
- binaire  lancement d’un nouveau Shell, chargement de l’exécutable
puis exécution.
- script  lancement d’un nouveau Shell puis interprétation des
commandes.

1.2 Les variables :

Il existe plusieurs type de variables :

 Utilisateur
 Système

1.2.1 Les Variables système :

Elles sont prédéfinies par le système et écrites en majuscules. (voir commande

set).
Signification des variables : se reporter au document annexe à ce TP
(caractères spéciaux reconnus par le prompt PS1 et Variables spéciales).
Pour visualiser le contenu d’une variable echo.
Exemple : echo $PATH

1.2.2 Variables définies par l’utilisateur :

Ces variables permettent de stocker des valeurs pour pouvoir les utiliser plus
tard. Elles n'ont pas besoin d'être déclarées. bash les créera dès la première
utilisation
Déclaration: variable=valeur (sans espaces)
Le signe = permet de faire l'affectation. Il est indispensable de ne pas mettre
d'espace avant ou après ce signe, ce qui est une erreur fréquente

2/18
Règles de constitution d’un nom :

Le nom est constitué par des lettres minuscules et majuscules, des chiffres et le
caractère soulignement.
Contrainte : pas de chiffre en tête, ni de soulignement.
Convention : variables utilisateur en minuscules.
valeur ne doit pas contenir d'espace non plus. Si on veut affecter une chaîne de
caractères en comprenant, on utilisera des guillemets :

phrase="une valeur avec des espaces"

Pour accéder ensuite à la valeur d'une variable, on préfixe son nom avec $ (dollar).
Celui-ci est sensible à la casse. Le moyen le plus simple de tester la valeur d'une
variable est d'utiliser la commande echo qui affiche ce qu'on lui passe en paramètre.
echo $phrase
⇒ une valeur avec des espaces

On peut également accéder à la valeur d'une variable en rajoutant des accolades autour
du nom, ce qui est parfois utile.
phrase="une valeur avec des espace" # des espace(sans ‘s’)
echo ${phrase}s
⇒ une valeur avec des espaces

Lister les variables :

set (sans argument)

Affecter du texte vide à une variable (une variable définie peut être vide) :
Exemple : b=

Supprimer une variable : unset

Exemple : unset var

Saisie de variables :

La commande read permet de saisir des variables.

Exemple : read v1 v2 v3 Affecte aux variables v1 v2 et v3 ce qu’elle lit sur
l’entrée standard, elle lit une ligne terminée par return et affecte les différents mots
aux variables.
Testez l’exemple suivant
read nom pronom datejour
BenHalima Mohamed 09 Mars 2008
ecbo $nom $prenom $datejour

Affectation d’expression à dam variables :

3/18
 Lorsqu’une commande est placée entre parenthèses suivant un $, cette commande
est remplacée par les sorties que fait la commande sur le canal standard
Exemples :
ici=$(pwd)
echo $ici
mes_fichiers=$(ls -l)
echo $mes_fichiers
L’expression entre parenthèse peut être complexe et associer des tubes.

Affichage de variables :

La commande echo admet les paramètres suivants permettant une mise en forme:
\a alarme sonore
\n saut de ligne
\b retour arrière
\t marque de tabulation
\c fin de la sortie et annulation saut de ligne
\\ affichage d’un backslash
\ On indication d’un nombre octal sut n positions pour caractères spéciaux
Exemple : echo « bonjour \n Albert »

Protection d’une variable :

Protéger une variable contre les modifications : readonly

la commande declare -r variable effectue la même action.
Exemple :
readonly variable
declara -r variable
Une commande verrouillée ne pourra pas être détruite. Elle restera dans le Shell
jusqu’à la fin de celle-ci.
Visualisez les variables verrouillées : readonly (sans arguments).

Durée de vie d’une variable :

La durée de vie d’une variable est égale à la durée de vie du Shell.

Les Shells scripts sont exécutés dans des Shells séparés (sauf pour les fonctions,
Cf. plus loin).
L’appel d’un script depuis un Shell actif lance un sous-Shell.
Une variable n’est définie que dans le Shell où elle a été crée.

Export variable :

La commande export permet d'étendre la définition d'une variable aux autres

Shells créés à partir de celui courant (soit explicitement, soit en lançant une
commande). Elle peut s'utiliser sur une variable déjà créée, ou l'initialisation peut
être faite en même temps.
variable_existante=valeur1
export variable_existante
export nouvelle_variable=valeur2

4/18
 La commande export utilisée seule montre toutes les variables exportées. Une
variable exportée peut être modifiée dans un sous-Shell. Mais les modifications ne
pourront être transmises qu’à des Shells de niveau inférieur. Elles ne seront pas
reportées aux Shells de niveau supérieur

Typage dune variable :

Il est possible d’affecter à une variable le type integer (entier) à l’aide de la

commande declare :
Exemple :
declare -r nombre
nombre=3*9
echo $nombre
nombre=Deux
echo $nombre
L’essai d’affectation d’une chaîne de caractères cette variable conduit à une valeur
systématiquement nulle.
La valeur d’une variable entière peut être affectée par la commande let. La
commande let permet de modifier ultérieurement une variable entière, dans ce cas
on peut omettre le $.
Exemple :
declare -i nombre
Nombre = 20
let a=b= nombre = 20%3
echo $a $b $nombre

Ordre de priorité des opérateurs :

Les différents opérateurs sont traités par ordre de priorité (que l’on ne connaît pas
forcément par cœur!). Il est conseillé de placer des parenthèses pour forcer l’ordre
souhaité.
Exemples :
declare -i a
a=“7 < (16/2)”
echo $a
Expliquez le résultat

Les tableaux :

bash permet aussi d'avoir des variables tableaux. Celles-ci sont des tableaux associatifs.
La clé pour y accéder peut être n'importe quelle chaîne de caractères. Par défaut ce
seront des numériques commençant à 0. Les tableaux sont aussi créés automatiquement.
Pour initialiser un tableau en une seule opération :

tableau1=(valeur0 valeur1 valeur2)

On accède ensuite à un élément par ${tableau[clé]} où clé sera ici un nombre entre 0 et
2.

5/18
 echo ${tableau1[2]}

⇒ valeur2

On peut par cette même notation affecter une valeur à l'élément du tableau. Si on
affecte la valeur à un élément qui n'existe pas encore, il sera créé. Il ne doit pas
nécessairement être à la suite du dernier élément. On peut créer celui d'indice 5 sans
que les 3 et 4 n'existent.

${tableau1[5]}=valeur5

Pour créer un tableau en n'utilisant pas les indices par défaut, on utilisera la syntaxe
suivante :

tableau2=([clé0]=valeur0 [clé1]=valeur1 [clé2]=valeur2)

Où les clés peuvent être n'importe quelles chaînes de caractères. A un tableau créé avec
les index numériques par défaut, on peut très bien ajouter un élément dont la clé est une
chaîne de caractères.

1.3 Utilisation des guillemets :

Il y a 3 types de guillemets à utiliser.

a) Les guillemets doubles ("). Leur rôle est de regrouper plusieurs chaînes de
caractères séparées par des espaces. Si un programme accepte un seul paramètre,
l'exécution suivante génèrera une erreur :
 ma_commande une phrase en paramètre
⇒ Erreur : ma_commande n'accepte qu'un paramètre

Car là on lui a passé 4 paramètres. Alors que dans le cas suivant, ma_commande
recevra un seul paramètre contenant la chaîne complète :

 ma_commande "une phrase en paramètre"

⇒ Résultat de ma_commande

Cela est aussi utile pour affecter à une variable une chaîne de caractères
comprenant des espaces.

Si une variable est contenue entre les doubles guillemets (avec le $ devant le
nom), elle est remplacée par sa valeur.

b) Les guillemets simples (') jouent le même rôle. La différence vient du fait
qu'aucune substitution de variable n'est effectuée. La chaîne comprise entre ' '
conservera les caractères $
c) Les guillemets inversés (`). Ils permettent d'exécuter une commande. La chaîne
comprise entre ` ` vaudra le résultat retourné par la commande. Les variables sont
remplacées par leurs valeurs avant l'évaluation de la commande. Cela est souvent
utilisé pour affecter un résultat à une variable. Pour l'exemple suivant, la commande
intégrée pwd permet d'afficher le répertoire courant.

6/18
 REPERTOIRE=`pwd`
echo $REPERTOIRE
⇒ /home/user01

Il existe une notation équivalente à la précédente. La commande peut être placée

entre $( ). L'exemple devient alors :

REPERTOIRE=$(pwd)

1.4 Expressions arithmétiques :

On peut facilement évaluer des expressions arithmétiques avec bash. Pour cela, on utilise la
notation $(( )) qui sera remplacée par le résultat du calcul mathématique. Voici les
opérations pouvant être utilisées par ordre de priorité inverse (extrait de la page de manuel
de bash) :

 - + plus et moins unaire

 ! ~ négations logique et binaire
 * / % multiplication, division, reste
 + - addition, soustraction
 << >> décalage arithmétique à gauche et à droite
 <= >= < > comparaisons
 == != égalité et différence
 & ET binaire
 ^ OU exclusif binaire
 | OU binaire
 && ET logique
 || OU logique
 = *= /= %= += -= <<= >>= &= ^= |= assignations

bash effectuera le remplacement par la valeur avant l'exécution des commandes

éventuelles.

1.5 Evaluation d’expressions conditionnelles :

La commande test :

Tester un fichier :

 test -option nomfic ou nomrep

 test -e fic (le fichier existant)
 test -f fic (est-ce un fichier normal?)
 test -d tic (est-ce un répertoire?)
 test -c fic (fichier orienté caractère?)
 test -b fic (orienté bloc?)
 test -p fic (tube nommé?)
 test -r fic (autorisation d’accès en lecture?)
 test -w fic(accès en écriture?)
 test -x fic(accès en éxécution?)
 test -s fic (vrai si fichier non vide)

7/18
 Tester chaîne de caractère :

 test -z « variable » (la chaîne de caractère est elle vide?)

 test -n « variable » (est-elle non vide?)
 test «$a» = toto (la variable $a contient elle toto?)
 test «$b» != tintin (la variable $b ne contient pas tintin?)

Tester une variable numérique (idem) :

 test «$nombre» -eq 5 (equal)

 … -ne 4 (not equal)
 … -lt 5 (less than)
 … -gt 4 (greater than)
 … -le 3 (less or equal)
 … -ge 2 (greater or equal)

Combinaison de tests :

 ! (négation du test)
 -a et logique
 -o Ou logique

Enchaînement de commandes :

En plus du tube | ou du ; déjà vu, le Shell permet d’enchaîner des commandes de manière
conditionnelle, la deuxième commande ne s’exécute que si la première a réussi && (valeur
0) ou si elle a échoué || (valeur 1).

Exemple :
test -r fic && echo «vous pouvez lire ce fichier»
test -s fic || echo «ce fichier n’est pas vide»

La commande test est très souvent en relation avec une structure de type if

1.6 Les structures de contrôle :

1.6.1 Instructions conditionnelles :

 Condition simple: if then ... fi

if commande ; then
liste de commandes
fi

 Condition avec alternative: if then ... else ... fi

if commande ; then
liste de commandes
else
liste de commandes
fi

8/18
 Condition multiple: if then ... elif then ... fi

if commande ; then
liste de commandes
elif commande ; then
liste de commandes
else
liste de commandes
fi
1.6.2 Instructions de boucle :

 Boucle for: for in do ... done

for variable [ in liste d'arguments ]

do
liste de commandes
done

Exemple 1:

for i in 1 2 3 4 5 6 7 8 9 10
do
echo $i
done

Exemple 2:

for fichier in *.txt

do
echo $fichier
done

 Boucle while: while do ... done

while commande
do
liste de commandes
done

 Boucle until: until do ... done

until commande
do
liste de commandes
done
1.6.3 Instructions de rupture de boucle :

 continuation de boucle: continue [n]

9/18
 ­ revenir au début de la boucle for, while, until
­ n = niveau de boucle à partir de la boucle la plus externe

for var1 in ${liste1}

do
for var2 in ${liste2}
do
if cmd2 ; then
continue 2
fi
done
done

 Sortie de boucle : break [n]

­ sortir d'une ou n boucles for, while, until

­ n = niveau de boucle à partir de la boucle la plus externe

 Sortie de programme: exit n

­ sortir d'un script-Shell avec un code de retour (n)

Exemple :

do

echo "donner un nom de fichier \c"

read fich
if [$fich=""]
then
break
fi
echo "doit on supprimer $fich \c"
read rep

if [$rep ="" -o $rep "NON"]

then
continue
else
rm $fic
fi

done

1.6.4 Instructions d'aiguillage :

 Aiguillage case: case in ... esac

case $variable in
motif1) liste de commandes ;;

10/18
 motif2) liste de commandes ;;
*) liste de commandes ;;
esac

Exemple:

case $# in
1) arg1=$1;;
2) arg1=$1; arg2=$2 ;;
0) echo "usage: $0 arg1 [ arg2 ]
exit 1;;
esac
1.6.5 Création de menu :

select
C’est une instruction bash qui permet la création de menus.

Structure Exemple
select var in PS3 = "Entrer votre choix : "
liste_var select fruit in pomme orange banane
do peche
do
commandes case $fruit in
pomme) echo "une pomme a 80
done calories";;
orange) echo "une orange a 65
calories";;
banane) echo "une banane a 100
calories";;
*) echo "Mauvaise entrée !";;
esac
done

 var et liste sont semblables à ceux de for. Liste désigne la liste d'options.
 La valeur de la variable réservée PS3 est utilisée comme prompt après l'énumération
des options de menus.
 Les entées avec le prompt sont enregistrées dans la variable REPLY .
 L'utilisateur sort de la boucle de menus en tapant le caractère ^D.

select fonctionne avec la liste des paramètres en l’absence du mot clé in (idem for et
while).

1.7 Le passage de paramètres :

11/18
 Le comportement d’un script peut être modifié en « passant » un ou plusieurs
paramètre(s) via la ligne de commande. Soit le script essai01.sh :

# !/bin/bash
#essai01.sh
echo le paramètre \$1 est \"$1\"
echo le paramètre \$2 est \"$2\"
echo le paramètre \$3 est \"$3\"

Tapez : essai01.sh un deux trois

Le résultat est :

…………………………….
…………………………….
…………………………….

Donc, les variables $1, $2, …, $9 contienne les « mots » numéro 1, 2, …,9 de la ligne
de commande.

Attention : par mot en entends ensemble de caractères ne contenant pas de caractères

de séparations. Les caractères de séparation sont l’espace, la tabulation et le point
virgule.

Tapez : essai01.sh *

Le résultat est :

…………………………….
…………………………….
…………………………….

Tapez : essai01.sh \*

Que ce passe t-il :

……………………………………………………………………………………………
………………………………………………………………………………………

1.8 Les fonctions :

Le langage du Shell est un langage procédural. Cela signifie que l'on peut créer des
fonctions pour regrouper des séries d'instructions couramment exécutées. La syntaxe
permettant d'écrire de telles fonctions est la suivante :

function nom () {
…
instructions

12/18
 …
}

où nom est le nom de la fonction, et instructions est la liste des commandes à

exécuter dans cette fonction.

 appel de fonction: nom [arg ...]

 pas de déclaration d'arguments entre parenthèses ()
 les fonctions doivent être définies avant leur utilisation

Les fonctions reçoivent les paramètres d’appel dans les variables $1 à $9 et $*. La
valeur de $0 reste inchangée.

Exemple :

Ecrire une fonction dir affichant les répertoires du répertoire courant

dir ( ) {
clear
echo «Répertoire courant : $(pwd)»
for w in $(ls)
do
if [-d $w]
then
echo $w
fi
done

Il est possible de déclarer des variables locales à une fonction en utilisant la commande
locale avant la déclaration de la variable. Dans ce cas, la modification de la variable
locale ne modifie pas une variable globale portant le même nom.

Les fonctions peuvent retourner une valeur numérique en code de retour. Cette valeur
peut être indiquée à l'aide de l'instruction return.

Par exemple, la fonction suivante calcule la somme des entiers de 0 à la valeur de

l'entier qu'elle reçoit en paramètre :

function somme () {
local result=0
local i=0
while [ $i -le $1 ] ;
do
result=$(($result + $i))
i=$(($i + 1))
done
return $result
}

13/18
 Ce code d'erreur pourra être récupéré par l'appelant dans la variable d'environnement
$? :
somme 10
echo $?

2. Exercices:

1. Ecrire un script Shell qui affiche les répertoires de votre répertoire courant.
2. Ecrire un script Shell qui calcule le carré d’un nombre entier différent de zéro.
3. Ecrire un script Shell qui transforme les caractères majuscules des noms de fichiers de
votre répertoire courant en caractères minuscules (utiliser typeset).
4. Ecrire un script Shell qui demande à l'utilisateur s'il souhaite afficher ou non les fichiers
cachés du répertoire courant.
5. Ecrire un script Shell qui affiche les 100 premiers nombres.
6. Ecrire un script Shell qui permet de renommer tous nos fichiers *.tar.gz en
*.tar.gz.old.
7. Ecrire un script Shell qui permet de tester la présence de l'utilisateur user01 dans le
fichier /etc/passwd.
8. Ecrire un script Shell qui reçoit trois paramètres et qui affiche leurs valeurs. Un
message d'erreur sera affiché si le nombre de paramètres est différent de trois.
9. Donnez le programme Shell qui permet d’afficher le contenu des fichiers donnés
comme paramètre. Faites en sorte qu’il demande à chaque fichier une confirmation.
10. Ecrire un programme Shell qui permet de tester si deux fichiers donnés en paramètres
sont liés (commande test fichier1 –ef fichier2)
11..Ecrire un programme Shell qui permet de tester si le fichier1 est plus récent que le
fichier2 (les deux fichiers sont donnés en paramètres). (commande test
fichier1-nt fichier2)
12. Ecrire un programme Shell qui permet de tester si le fichier2 est plus récent que le
fichier1 (les deux fichiers sont donnés en paramètres). (commande test
fichier1-ot fichier2)
13. Ecrire un programme Shell qui reçoit plusieurs paramètres (des noms de fichiers). Pour
chaque fichier reçu, il s’agit d’effectuer les tâches suivantes
a. Si le fichier est ordinaire vous lui ajouter le droit de lecture, s’il ne l’a pas déjà.
b. Si le fichier est un répertoire vous lui ajoutez le droit « x ».
c. - Sinon vous réinitialisez toute la chaîne de permission relative au propriétaire à
«rwx ».

14/18
 14. Ecrire un script qui reçoit comme paramètre un nom de fichier s’il ne reçoit aucun
paramètre, il doit afficher un message d’erreur: paramètre manquant. Le fichier reçu
comme paramètre sera afficher en indiquant sont type et ses droit d’accès.
15. Le script boucle affiche des nombres à l’écran il sait traiter jusqu’à trois paramètres. Le
premier est la valeur de départ, le second est la valeur finale et le 3ème est l’incrément.
Si deux paramètres seulement sont spécifiés, l’incrément par défaut sera 1. En présence
d’un paramètre unique, la valeur final sera 20. En absence de tout paramètres on affiche
tous les chiffres entre 1 et 20 avec un pas égale à 1.
16. Ecrire un script qui permet d'afficher le squelette d'un menu de la façon suivante :

Menu

1 choix 1
2 choix 2
3 choix 3
4 choix 4
0 Quitter
Entrez votre choix: -

17. Ecrire un script qui permet de copier la sous arborescente d'un répertoire dans un autre.
Ce script admet deux paramètres, le premier est la sous arborescence à copier et le
deuxième est le répertoire où on va faire la copie.

3. Annexe :
3.1 Variables d’environnement prédéfinies :
HOME Chemin absolu du répertoire personnel
IFS Caractères séparateur des mots, le blanc par défaut
LOGNAME Le login
MAIL Définit le fichier où le système va voir si l’utilisateur a reçue des messages.
Intervalle de temps respecté par le Shell avant d’aller vérifier la BAL
MAILCHECK
(exprimé en s)
liste de fichiers supplémentaires à parcourir pour le courrier, les fichiers sont
MAILPATH
séparés par des :, le signe % suivi d’un texte affiche un message.
liste des répertoires séparés par :, permet de spécifier au Shell l’ordre de
PATH
recherche des commandes externes
facilite le changement de répertoire par CD en indiquant les répertoires dont
CDPATH
les sous répertoires doivent être parcourus
BASH chemin d’accès absolu vers le nom du Shell utilisé
BASH_VERSION version du BASH
PS1 prompts standard que le Shell affiche à l’écran
PS2 contenu affiché en cas d’erreur de syntaxe
Utilisé par la commande select pour afficher un prompt devant les entrées
PS3
des menus
PS4 valeur par défaut + pour compatibilité avec le boume Shell
RANDOM contient à chaque accès une valeur aléatoire comprise entre 0 et 32767

15/18
 Contient le nom du fichier à exécuter à chaque appel du Shell, contient
ENV
souvent ~/.bashrc.
HISTFILE Nom du fichier historique des commandes, par défaut ~/.sh_history
Nombre de commandes devant être enregistrées dans le fichier historique
HISTSIZE
(500 par défaut), attention ça passe par des mémoires tampons
permet de ne pas définir de variable pour stocker une saisie utilisateur, la
REPLAY
commande read ou select peuvent lire la réponse de l’utilisateur ici.
SECONDS nombre de secondes depuis l’activation du Shell
VISUAL contient vi ou emacs on détermine quel éditeur est intégré au Shell
SHELL type de Shell utilisé (AIX)
TERM type de terminal (AIX)
EDITOR nom de l’éditeur à utiliser (AIX)
PWD répertoire courant (AIX)
PPID numéro du process père (AIX)
OLDPWD Nom du répertoire précédent (AIX)

3.2 La variable PS1 peut contenir les caractères spéciaux suivants :

\t heure actuelle
\d date actuelle
\n saut de ligne
\s Nom du Shell
répertoire de travail, un ~ s’affiche si l’on se trouve dans le
\w
répertoire personnel
\u nom d’utilisateur
\h nom de l’ordinateur
\! numéro de commande courant
\nnn Remplacé par le caractère représenté par nnn en base 8
\\ un backslash

3.3 Variables spéciales :

Elles ne sont accessibles qu’en lecture, elles sont gérées par le Shell.
$?;valeur de retour de la dernière commande exécutée
$$ numéro du process en cours (PID)
$ ! numéro du dernier process en arrière plan
$- option du Shell
$0 premier paramètre (nom de la commande)
$1 2eme paramètre
…
$9 10eme paramètre
$* tous les paramètres
$@ tous les paramètres sous forme séparée
$# Nombre de paramètres passé à la commande
Opérateurs sur les variables entières :
+-*/ Opérations de base sur les variables entières (integer)
% modulo reste de la division entière (integer)
< > >= <= comparaison, la valeur retournée sera 1 si vrai O si faux
= = != égalité et inégalité
&& || comparaison avec le ET logique ou le OU logique

16/18
 comparaison bit à bit de la variable & (ET), | (OU), ^ (OU
&|^
exclusif)

3.4 Opérateurs sur les variables caractères :

recherche de la plus petite occurrence du critère de recherche au

#
début du texte
recherche de la plus grande occurrence du critère de recherche au
##
début du texte
recherche de la plus petite occurrence du critère de recherche à la fin
%
du texte
recherche de la plus grande occurrence du critère de recherche à la
%%
fin du texte

17/18
3.5 Les Shells

• sh ("Bourne Shell", Steve Bourne)

o Shell historique (disponible sur tous les Unix)
• csh ("C-Shell", Bill Joy)
o Shell BSD (disponible sur tous les Unix)
• ksh ("Korn Shell")
o Shell normalisé POSIX (P1003.2) et ISO (HP, Solaris)
• bash ("Bourne again Shell" de Brian Fox et Chet Ramey)
o Ksh du domaine public (installé sur toutes les machines)
• zsh ("Zero Shell")
o Ksh du domaine public (installé sur toutes les machines)
• tcsh ("Toronto C-Shell")
• rc (Plan9, Tom Duff)

3.6 Caractères de contrôle au clavier

• Caractères de contrôle non gérés par le Shell
o <cr> fin de ligne (retour chariot) mappé en <cr><lf>
o <lf> fin de ligne (nouvelle ligne) mappé en <cr><lf>
o <tab> tabulation
o <bs> ^H, backspace, effacement du caractère précédent
o <del> ^?, souvent identique à <bs>
o <^C> interruption d'un processus attaché au terminal
o <^\> arrêt d'un processus avec vidage mémoire (core)
o <^Z> suspension d'un processus en premier plan
o <^U> effacement de la ligne complète
o <^W> effacement du mot qui précède
o <^D> fin de fichier => si le Shell lit, fin d'un Shell
o <^S> suspension de l'affichage écran (Xoff)
o <^Q> reprise de l'affichage écran (Xon)
• Gestion des caractères de contrôle par stty
o stty erase ^H kill ^U intr ^C susp ^Z quit ^\ eof ^D

18/18