Machine Translated by Google

Programmation Shell
Machine Translated by Google

Scripts Shell (1)

u Fondamentalement, un script shell est un fichier texte sous Unix
commandes dedans.
u Les scripts Shell commencent généralement par un # ! et une coquille
nom
– Par exemple : #!/bin/sh
– Si ce n'est pas le cas, le shell actuel de l'utilisateur sera utilisé
u N'importe quelle commande Unix peut être insérée dans un script shell
– Les commandes sont exécutées dans l'ordre ou dans le flux
déterminé par les instructions de contrôle.
u Différents shells ont des structures de contrôle différentes

­ Le #! la ligne est très importante –

Nous écrirons des scripts shell avec le shell Bourne (sh)
Machine Translated by Google

Scripts Shell (2)

uPourquoi écrire des scripts shell ?

– Pour éviter les répétitions :

vSi vous effectuez une séquence d'étapes avec

des commandes Unix standard encore et encore,
pourquoi ne pas tout faire avec une seule commande ?

– Pour automatiser les tâches difficiles :

De nombreuses commandes comportent des options

subtiles et difficiles que vous ne voulez pas comprendre
ou mémoriser à chaque fois.
Machine Translated by Google

Un exemple simple (1)

u tr abcdefghijklmnopqrstuvwxyz \
thequickbrownfxjmpsvalzydg < file1 > file2 –
« crypte » le fichier1 dans le fichier2
u Enregistrez cette commande dans des fichiers de script shell :
– myencrypt #!/
bin/sh

tr abcdefghijklmnopqrstuvwxyz \
thequickbrownfxjmpsvalzydg –
mydecrypt #!/
bin/sh

tr thequickbrownfxjmpsvalzydg \
abcdefghijklmnopqrstuvwxyz
Machine Translated by Google

Un exemple simple (2)

uchmod les fichiers à être exécutables ;
sinon, vous ne pourriez pas exécuter les scripts
obelix[3] > chmod u+x myencrypt mydecrypt

uExécutez­les comme des commandes normales :

obelix[4] > ./myencrypt < fichier1 > fichier2

obelix[5] > ./mydecrypt < fichier2 > fichier3
obelix[6] > diff fichier1 fichier3

N'oubliez pas : ceci est nécessaire

lorsque "." n'est pas sur le chemin
Machine Translated by Google

Variables du shell Bourne

uRappelez­vous : les variables du shell Bourne sont
différentes des variables de csh et tcsh !
– Exemples en sh :
CHEMIN=$CHEMIN:$HOME/bin
Remarque : pas
HA=1 $ d'espace autour =

PHRASE="Maison sur la colline"

export PHRASE Faire de PHRASE une
variable d'environnement
Machine Translated by Google

Affectation d'une sortie de commande à une variable

uÀ l'aide de guillemets, nous pouvons attribuer

la sortie d'une commande à une variable :
#!/bin/sh
fichiers=`ls`

echo $files

uTrès utile en calcul numérique : #!/bin/sh

valeur=`expr 12345 + 54321` echo

$valeur
Machine Translated by Google

Utiliser expr pour les calculs

u Variables comme arguments :
% nombre=5
% count=`expr $count + 1` %
echo $count
6
– Les variables sont remplacées avec leurs valeurs par le shell !
u expr prend en charge les opérateurs suivants :
– opérateurs arithmétiques : +,­,*,/,
% – opérateurs de comparaison : <, <=, ==, !=,
>=, > – opérateurs booléens/
logiques : &, | –
parenthèses : (, ) – la priorité est la même que C, Java
Machine Translated by Google

Déclarations de contrôle

uSans instructions de contrôle, l'exécution dans un

script shell passe successivement d'une
instruction à la suivante.
uLes instructions de contrôle contrôlent le flux
d'exécution dans un langage de programmation.
uLes trois types d'instructions de contrôle les plus
courants : –
conditionnelles : if/then/else, case, ... –
instructions de boucle : while, for, jusqu'à, do, ...
– instructions de branchement : appels de sous­
programmes (bons), goto (mauvais)
Machine Translated by Google

Boucles for

Les boucles ufor permettent la répétition d'une commande pour

un ensemble spécifique de valeurs

uSyntaxe :
for var in value1 value2 ...
faire

command_set
terminé

– command_set est exécuté avec chaque valeur de var

(value1, value2, ...) dans l'ordre
Machine Translated by Google

Exemple de boucle for (1)

#!/bin/sh #

timestable – imprimer une table de multiplication pour i en 1

23
faire

pour j dans 1 2
3

do value=`expr $i \* $j`
echo ­n "$value " done

écho
fait
Machine Translated by Google

Exemple de boucle for (2)

#!/bin/sh

# file­poke – dites­nous des trucs sur les fichiers

files= `ls `
for i in $files do

echo ­n "$i " grep

$i $i done

– Rechercher des noms de fichiers dans les fichiers du répertoire actuel

Machine Translated by Google

Exemple de boucle for (3)

#!/bin/sh

# file­poke – dites­nous des informations sur les

fichiers pour i
in * ; do echo ­n
"$i " grep $i
$i done

– Identique à la diapositive précédente, mais un

peu plus condensée.
Machine Translated by Google

Conditions
u Les conditions sont utilisées pour « tester » quelque chose.
– En Java ou C, ils testent si une variable booléenne est vraie ou
fausse.

– Dans un script shell Bourne, la seule chose que vous pouvez

tester est de savoir si une commande est « réussie » ou non.

u Chaque commande bien exécutée renvoie un code retour.

– 0 si c'est réussi

– Différent de zéro en cas d'échec (en fait 1..255)

– Nous verrons plus tard que cela est différent des conditions vrai/
faux en C.
Machine Translated by Google

L'instruction if
uForme simple : si
décision_command_1 alors

commande_set_1 grep renvoie 0 s'il trouve quelque chose qui

être
renvoie une valeur différente de zéro, sinon

uExemple : si
grep unix myfile >/dev/null alors

echo "C'est là"

être rediriger vers /dev/null afin que les

résultats "intermédiaires" ne soient pas

imprimés
Machine Translated by Google

si et sinon

si grep "UNIX" monfichier >/dev/null alors

echo UNIX se produit dans mon fichier

sinon

écho Non !

echo UNIX ne se produit pas dans mon fichier fi

Machine Translated by Google

si et elif
si grep "UNIX" monfichier >/dev/null alors

echo "UNIX apparaît dans le fichier"

elif grep "DOS" monfichier >/dev/null puis

echo "Unix ne se produit pas, mais DOS oui"

autre

echo "Personne n'est là" fi

Machine Translated by Google

Utilisation de points­virgules

uAu lieu d'être sur des lignes distinctes, les

instructions peuvent être séparées par
un point­virgule (;)
– Par exemple : if
grep "UNIX" monfichier ; puis faites écho à "Compris" ;
fi – Cela fonctionne réellement n'importe où dans le

$cwd % cwd=
shell. ` mot de passe` ; cd $HOME ; ls ; cd
Machine Translated by Google

Utilisation du côlon

u Parfois, il est utile d'avoir une commande

qui ne fait « rien ». u La
commande : (deux­points) sous Unix ne fait rien #!/bin/sh

si grep unix mon fichier

alors
:
autre

echo "Désolé, Unix n'a pas été trouvé"

être
Machine Translated by Google

La commande test – Tests de fichiers

u test –f file le fichier existe­ t­il et n'est­il pas un répertoire ? u test

­d file le fichier existe­t­il et est­il un répertoire ? u test –x
fichier le fichier existe­t­il et est­il exécutable ? u test –s le

fichier existe ­ t­il et fait­il plus de 0 octet ?

#!/bin/sh
compte=0
pour moi dans
* ; faire si test –x $i;
alors count=`expr $count + 1` fi

done
echo Total de $count fichiers exécutables.
Machine Translated by Google

La commande test – Tests de chaînes

u test –z la chaîne est une chaîne de longueur 0 ? u

test string1 = string2 est­ce que string1 est égal à string2 ? vous testez
string1 != string2 n'est pas égal ? u Exemple : si
test ­z
$REMOTEHOST alors

:
autre
DISPLAY="$REMOTEHOST:0" exporter
DISPLAY fi
Machine Translated by Google

La commande test – Tests entiers

uLes entiers peuvent également être comparés :
– Utilisez ­eq, ­ne, ­lt, ­le, ­gt, ­ge
uPar exemple : #!/bin/
sh
le plus petit = 10 000

pour je dans 5 8 19 8 7 3; faire

si test $i ­lt $le plus petit ; alors le
plus petit=$i
être

fait

echo $le plus petit

Machine Translated by Google

Utilisation de [ ]

u Le programme de test a un alias comme [ ]

– Chaque support doit être entouré d'espaces !
– C’est censé être un peu plus facile à lire. u Par exemple :

#!/bin/sh

le plus petit = 10 000

pour i dans 5 8 19 8 7 3 ; faire
if [ $i ­lt $le plus petit ] ; alors le
plus petit=$i
être

fait
echo $le plus petit
Machine Translated by Google

La boucle while
Les boucles uWhile répètent les instructions tant que
la prochaine commande Unix réussit.
u Par exemple : #!/
bin/sh
je = 1

somme=0

while [ $i ­le 100 ]; do

sum=`expr $sum + $i` i=`expr
$i + 1` done echo
La
somme est $sum.
Machine Translated by Google

Les boucles jusqu'à

ce que les boucles uUntil répètent les instructions jusqu'au prochain

La commande Unix a réussi.
u Par exemple :

#!/bin/sh
x=1

jusqu'à [ $x ­gt 3 ]; faire

echo x =
$xx=`expr $x + 1`
terminé
Machine Translated by Google

Arguments de ligne de commande (1)

u Les scripts Shell ne seraient pas très utiles si nous ne pouvions pas leur
transmettre des arguments sur la ligne de commande

u Les arguments du script Shell sont « numérotés » à partir de la gauche

à droite
– $1 – premier argument après la commande
– $2 ­ deuxième argument après la commande
–
... jusqu'à 9 $
– Ils sont appelés « paramètres positionnels ».
Machine Translated by Google

Arguments de ligne de commande (2)

uExemple : obtenir une ligne particulière d'un fichier

– Écrivez une commande au format :

getlineno numéro de ligne nom de

fichier #!/bin/sh

tête ­1$ 2$ | tail ­1

uAutres variables liées aux arguments : v$0 nom de la

commande exécutée v$* Tous les arguments
(même s'il y en a plus de 9) v$# le nombre
d'arguments
Machine Translated by Google

Arguments de ligne de commande (3)

u Exemple : imprimer les fichiers les plus anciens d'un répertoire
#! /bin/sh

# plus ancien ­­ examine les parties les plus anciennes d'un répertoire
COMBIEN = quart de travail

de 1 $

ls ­lt $* | queue +2 | tail $HOWMANY

u La commande shift décale tous les arguments vers la gauche – $1 =
$2, $2 =$3, $3 = $4, ... – $1 est
perdu (mais nous l'avons sauvegardé dans $HOWMANY)
– La valeur de $# est modifiée ($# ­ 1) –
utile lorsqu'il y a plus de 9 arguments u La commande
« tail +2 » supprime la première ligne.
Machine Translated by Google

En savoir plus sur les variables Bourne Shell (1)

uIl existe trois types de variables de base dans

un script shell :
– Variables de position...
v$1, $2, $3, ..., $9 –
Variables de mots clés...
vLike $PATH, $HOWMANY et tout ce que nous
pouvons définir.
– Variables spéciales...
Machine Translated by Google

En savoir plus sur les variables Bourne Shell (2)

uVariables spéciales :
– $*, $# ­­ tous les arguments, le nombre de
les arguments
– $$ ­­ l'identifiant du processus du shell actuel
– $? ­­ valeur de retour du dernier premier plan
processus à terminer
­­ nous en reparlerons plus tard

– Il y en a d’autres avec qui vous pourrez vous renseigner

mec merde
Machine Translated by Google

Lecture des variables à partir de l'entrée standard (1)

u La commande read lit une ligne d'entrée du

terminal et l'affecte aux variables données en
arguments

u Syntaxe : lire var1 var2 var3 ...

vAction : lit une ligne d'entrée à partir de l'entrée standard
vAssignez le premier mot à var1, le deuxième mot à var2, ...
vLa dernière variable récupère tous les mots en excès sur le
doubler.
Machine Translated by Google

Lecture des variables à partir de l'entrée standard (2)

u Exemple : %
lu XYZ

Voici quelques mots en entrée %

echo $X
Ici
% écho $Y
sont

% echo $Z
quelques mots en entrée
Machine Translated by Google

L'exposé du cas

u L'instruction case prend en charge plusieurs voies

branchement basé sur la valeur d’une seule chaîne.
u Forme générale :
chaîne de cas
dans le
modèle 1) command_set_11
;;
modèle2)
command_set_2
;;
…
esac
Machine Translated by Google

cas Exemple
#!/bin/sh
'
echo ­n 'Choisissez la commande [1­4] > lire
la réponse
echo

cas $réponse en
"1") Utilisez le symbole de tuyau « | » comme une
date logique ou entre plusieurs choix.

;;

"2"|"3") mot

de passe

;;

"4")
ls Fournissez un cas par défaut lorsqu’aucun
autre cas ne correspond.

;;

*) echo Choix illégal !

;;
esac
Machine Translated by Google

Redirection dans les scripts Bourne Shell (1)

u L'entrée standard est redirigée de la même manière
(<). u La sortie standard peut être redirigée de la même manière (>).
– Peut également être dirigé en utilisant la
notation 1> – Par exemple : cat x 1> ls.txt
(uniquement stdout) u L'erreur standard est redirigée en
utilisant la notation 2> – Par exemple : cat xy 1>
stdout.txt 2> stderr. txt u La sortie standard et l'erreur standard pe
redirigé vers le même fichier en utilisant la notation 2>&1 – Par
exemple : cat xy > xy.txt 2>&1
u La sortie standard et l'erreur standard peuvent être redirigées
vers la même commande en utilisant une notation similaire
– Par exemple : chat xy 2>&1 | texte greffé
Machine Translated by Google

Redirection dans les scripts Bourne Shell (2)

u Les scripts Shell peuvent également fournir une entrée standard à
commandes à partir du texte intégré dans le script lui­même.
u Forme générale : commande << mot
– L'entrée standard pour la commande suit cette ligne jusqu'à
la ligne commençant par mot, mais sans l'inclure.
u Exemple :
#!/bin/sh
grep 'bonjour' << EOF Seules ces deux lignes seront mises
en correspondance et affichées.
Ceci est un exemple de texte.
Voici une ligne avec bonjour dedans.
Voici une autre ligne avec bonjour.
Plus de lignes avec ce mot.
EOF
Machine Translated by Google

Un exemple de script Shell (1)

uSupposons que nous ayons un fichier appelé
marks.txt contenant les notes suivantes des étudiants :

091286899 90 H. Blanc
197920499 80 J. Brun
899268899 75 R. Vert
……

uNous souhaitons calculer des statistiques sur

les notes dans ce fichier.
Machine Translated by Google

Un exemple de script Shell (2)

#!/bin/sh

somme=0; nombre d'échecs = 0 ; compte=0 ;

tout en lisant le nom de la classe du numéro d'étudiant ; do

sum=`expr $sum + $grade` count=`expr

$count + 1` if [ $grade ­lt 50 ]; alors

countfail=`expr $countfail + 1`

être

done

echo La moyenne est `expr $sum / $count`. echo $countfail les

étudiants ont échoué.
Machine Translated by Google

Un exemple de script Shell (3)

uSupposons que le script shell précédent ait été
enregistré dans un fichier appelé statistiques.

uComment pourrions­nous l’exécuter ?

uComme d'habitude, de plusieurs

manières... – % cat marks.txt |
statistiques – % statistiques <marks.txt

uNous pourrions également simplement exécuter des

statistiques et fournir des notes via une entrée standard.