Le shell (coquille en anglais), designe l'interpreteur de commandes du systeme Linux.
Ce langage comporte les notions de parametres, variables et structures de controle.
Son role est de faciliter les taches d'administration systeme, et le travail des utilisateurs.
Un fichier de commandes est un fichier ordinaire (texte), dans lequel sont ecrites les successions de commandes a interpreter et executer par le systeme. Cela permet a un utilisateur de creer ses propres fonctions et de personnaliser son environnement de travail. On appelle souvent un fichier de commandes un script.
1.2 Ecriture d'un fichier de commandes
On cree, ou on modifie un fichier de commande, par l'intermediaire d'un traitement de texte. Pour retrouver ses petits, deux methodes existent :
- placer ses scripts dans un repertoire particulier;
- creer un repertoire par activite (client, type de travail, ..) pour y placer les scripts et les fichiers relatifs a cette activite.
Les commandes :
- les commandes definies par une fonction shell (Bourne ou Korn-shell), un alias (C-Shell ou Korn-shell), s'effectuent sans creation de processus;
- les commandes internes du shell : pas de creation deprocessus;
- les commandes externes, independantes du shell, et situees dans divers repertoires (/bin, /usr/bin, /sbin, /usr/sbin, etc...); le lancement de ces commandes cree un nouveau processus a chaque fois.
Les variables shell :
- une variable est une entite definie par son nom, et contenant une valeur. Le nom est une chaine de caracteres commencant par une lettre. La valeur d'une variable est une chaine de caracteres. La valeur peut etre specifiee au lancement du script, ou demandee a l'utilisateur lors de l'execution du script, ou encore renvoyee par une des commandes appelees par le script;
- une variable interne n'est connue que par le shell;< /FONT>
- une variable d'environnement est connue par le shell et les processus lances par le shell.
Il existe plusieurs shells, dont les plus repandus sont le Bourne-shell (ou son alternative le BASH : Bourne Again SHell), le C-shell et le Korn-shell (plus reserve au monde UN*X, tres peu connu sous Linux). Nous avons, en alternative au C-shell, un peu ancien, le Z-shell, qui reprend les principes du C-shell, en rajoutant une certaine puissance, mais, egalement, une certaine difficulte d'utilisation et de configuration. Nous parlerons plus precisemment du Bourne-shell, car c'est l' "ancetre", si je puis dire ;-)
Chaque shell utilise des fichiers d'initialisation particuliers qui servent a creer ou modifier des variables internes du shell, des variables d'environnement, de creer de nouvelles commandes ou fonctions, de creer des alias, etc...
2. Caracteristiques communes aux shells
Les commandes sont delimitees par une fin de ligne ou par un ';'.
Les arguments sont au nombre de 9, de $1 a $9, ils sont au nombre de $# (c'est a dire que si, dans le script, on veut savoir combien on a de parametres, on verifie la variable $# : echo $#, affiche le nombre de parametres transmis au script), et on peut tous les utiliser en une fois par $* ou $@, le nom de la commande executee etant placee dans $0.
L'interpretation des metacaracteres :
# : commentaire
" " : chaine de caracteres remplacee par sa valeur
' ' : chaine de caractere
` ` (alt+7) : valeur renvoyee par une commande
Deux fichiers sont executes avant l'interpretation des commandes :
- /etc/profile : gere par l'administrateur du systeme, commun a tous les utilisateurs
- .profile : situe dans le repertoire par defaut de chaque utilisateur, celui-ci pouvant le modifier pour personnaliser son environnement de travail (on y trouve generalement les alias : alias rm="rm -i" pour confirmation de suppression, alias ls="= ;ls -color" pour un ls en couleur, alias dir="ls", etc...).
La liste des variables et leur valeur est donnee par la commande set, sans argument.
La liste des variables d'environnement est donnee par la commande env ou setenv.
La commande unset parmet de supprimer une variable (sauf PATH, PS1, PS2, MAILCHECK et IFS).
La declaration d'une variable interne se fait par la commande export nom_variable.
L'affectation d'une valeur a une variable se fait par le signe = (sans espace) : variable=valeur.
La valeur d'une variable est obtenue en faisant preceder son nom par $ : echo $PATH.
VARIABLES RESERVEES :
Il existe des variables reservees a l'interpreteur.
| CDPATH | ==> | liste des chemins d'acces utilises par la commande cd en relatif |
| HOME | ==> | pointe sur le repertoire par defaut, et sert d'argument par defaut a cd |
| IFS | ==> | definit les delimiteurs de champs internes |
| ==> | permet de specifier le nom de la boite aux lettres | |
| MAILCHECK | ==> | donne l'intervalle de temps entre deux tests d'arrivee de nouveaux messages |
| MAILPATH | ==> | precise une liste de boites aux lettres separees par ':' |
| PATH | ==> | liste des chemins d'acces contenant des commandes, separes par le caractere ':' ; l'ordre dans la liste est celui de l'ordre de recherche des fichiers executables |
| PS1 | ==> | valeur du premier prompt ($ par defaut) ; par exemple : PS1="`WHOAMI`" |
| PS2 | ==> | valeur du second prompt (> par defaut) |
| TERM | ==> | definition du type de terminal; les terminaux connus sont decrits dans le fichier /etc/termcap ou dans /usr/lib/terminfo, selon le systeme |
On peut definir des fonctions shell, de maniere interactive, ou dans un script.
| Syntaxe : | fonction() {liste;} |
| Exemple : | rm() {
/bin/rm -i $* } |
Lorsque l'on quitte la session, la fonction est detruite. Si on veut conserver une fonction, il faut l'ecrire dans .profile
3.4 Commandes internes du shell
| cd [rep] | ==> | permet de changer de repertoire; la valeur par defaut de [rep] est le contenu de la variable HOME, le chemin d'acces celui de CDPATH |
| echo texte | ==> | affiche du texte a l'ecran |
| exec cmd | ==> | execute la commande cmd a la place du shell, sans creation d'une nouveau processus et sans retour possible au shell |
| exit [n] | ==> | entraine l'arret du shell avec le code retour egal a n |
| hash [-r] [nom] | ==> | hash nom inscrit le chemin d'acces a la commande (ou le script) nom, dans une table, d'ou une execution plus rapide; -r vide la table |
| pwd | ==> | affiche le repertoire courant |
| read [nom] | ==> | lecture au clavier; nom peut contenir plusieurs variables separees par des espaces |
| times | ==> | affiche le temps d'execution du shell |
| type [nom] | ==> | precise le type de commande et son chemin d'acces |
| sh [option] script [[arg1] [arg2] [...]] | ==> | execute le fichier script, sans autorisation d'execution; l'option -x est utilisee pour la mise au point |
| script [[arg1] [arg2] [...]] | ==> | methode normale; le script doit avoir l'autorisation d'execution (chmod U+x script); si la premiere ligne du script commence par un '#!', un autre shell est utilise |
TEST ::donne un code de retour nul si le resultat des tests est vrai.
| test chaine | ==> | vrai si chaine n'est pas vide |
| test -z chaine | ==> | vrai si chaine est vide |
| test ch1=ch2 | ==> | vrai si les deux chaines sont egales |
| test -f fichier | ==> | vrai si fichier existe et si c'est un fichier ordinai= re |
| test -d fichier | ==> | vrai si fichier existe et si c'est un repertoire |
| test -r fichier | ==> | vrai si fichier existe et est accessible en lecture |
| test -w fichier | ==> | vrai si fichier existe et est accessible en ecriture |
| test -x fichier | ==> | vrai si fichier existe et est executable |
IF :
if condition
then action1
[elif condition2
then action2]
[........]
[else actioni]
fi
CASE :
case mot in
cas1) commande1;;
cas2) commande2;;
...........
[*) commandei;;]
esac
FOR :
for var [in mot1 mot2 ...]
do
commandes ...
done
UNTIL :
until commandes1
do commandes2
done
WHILE :
while condition1
do commandes1
done
Merci, pour ce cours, a celui qui a ete mon prof pendant un trimestre, et qui adore les nains de jardin, surtout dans sa voiture, Mr P-L REICHSTADT.
Merci egalement a l'equipe de Line, de bien vouloir integrer ce petit cours a sa rubrique.
Enfin, merci a ma femme d'avoir baillonne le bebe pour me permettre d'ecrire ceci.
Quant a moi, vous pouvez me contacter :