« Programmation Bash/Tests » : différence entre les versions
Contenu supprimé Contenu ajouté
m Robot : ajoute Catégorie:Programmation bash-ksh (livre) |
→Syntaxe du test : précisions sur les tests avec variables |
||
| Ligne 1 : | Ligne 1 : | ||
{{Programmation Bash}} |
|||
== Conditions == |
|||
Deux syntaxes équivalentes permettent de tester des expressions : <code>[ expression ]</code> et <code>test expression</code>. Elles renvoient toutes les deux un code de retour valant 0 si l'expression est vraie et 1 si l'expression est fausse. |
|||
== Syntaxe du test == |
|||
Deux syntaxes équivalentes permettent de tester des expressions : |
|||
<pre> |
|||
[ expression ] |
|||
</pre> |
|||
ou |
|||
<pre> |
|||
test expression |
|||
</pre> |
|||
Ces deux commandes renvoient un code de retour valant 0 si l'expression est vraie et 1 si l'expression est fausse. |
|||
Exemple : |
|||
<pre> |
<pre> |
||
$ [ 2 = 2 ] |
$ [ 2 = 2 ] |
||
| Ligne 18 : | Ligne 31 : | ||
1 |
1 |
||
</pre> |
</pre> |
||
=== Tester une variable === |
|||
Il est tout à fait possible de tester le contenu d'une variable avec les commandes <code>test</code> ou <code>[</code> : |
|||
<source lang="bash"> |
|||
[ $a = toto ] |
|||
</source> |
|||
la substitution de la variable par sa valeur est alors effectuée est le test est vrai si la variable contient la valeur <code>toto</code> et faux sinon. Par contre, si la variable <code>a</code> n'est pas définie lors du test, la substitution de la ligne sera : |
|||
<source lang="bash"> |
|||
[ = toto ] |
|||
</source> |
|||
ce qui provoquera une erreur. Il est donc préférable de toujours protéger une variable lors d'un test soit avec des guillemets : |
|||
<source lang="bash"> |
|||
[ "$a" = toto ] |
|||
</source> |
|||
soit avec un préfixe : |
|||
<source lang="bash"> |
|||
[ x$a = xtoto ] |
|||
</source> |
|||
== Tests sur les objets du système de fichiers == |
|||
Les opérateurs de tests disponibles sont, pour les les objets du système de fichiers : |
|||
* <code>[ -e $FILE ]</code> |
|||
vrai si l'objet désigné par $FILE existe dans le répertoire courant, |
|||
* <code>[ -s $FILE ]</code> |
|||
vrai si l'objet désigné par $FILE existe dans le répertoire courant et si sa taille est supérieure à zéro, |
|||
* <code>[ -f $FILE ]</code> |
|||
vrai si l'objet désigné par $FILE est un fichier dans le répertoire courant, |
|||
* <code>[ -r $FILE ]</code> |
|||
vrai si l'objet désigné par $FILE est un fichier lisible dans le répertoire courant, |
|||
* <code>[ -w $FILE ]</code> |
|||
vrai si l'objet désigné par $FILE est un fichier inscriptible dans le répertoire courant, |
|||
* <code>[ -x $FILE ]</code> |
|||
vrai si l'objet désigné par $FILE est un fichier exécutable dans le répertoire courant, |
|||
* <code>[ -d $FILE ]</code> |
|||
vrai si l'objet désigné par $FILE est un répertoire dans le répertoire courant. |
|||
== Tests sur les chaînes de caractères == |
|||
Les opérateurs de tests disponibles sont, pour les chaînes : |
Les opérateurs de tests disponibles sont, pour les chaînes : |
||
* <code>c1 = c2</code> |
* <code>[ c1 = c2 ]</code> |
||
vrai si c1 et c2 sont égaux, |
|||
* <code>c1 != c2</code> |
* <code>[ c1 != c2 ]</code> |
||
vrai si c1 et c2 sont différents, |
|||
* <code>-z c</code> |
* <code>[ -z c ]</code> |
||
vrai si c est la chaîne vide (''Zero''), |
|||
* <code>-n c</code> |
* <code>[ -n c ]</code> |
||
vrai si c n'est pas la chaîne vide (''Non zero''). |
|||
== Tests sur les nombres == |
|||
Pour les nombres : |
Pour les nombres : |
||
* <code>n1 -eq n2</code> |
* <code>[ n1 -eq n2 ]</code> |
||
vrai si n1 et n2 sont égaux (''EQual''), |
|||
* <code>n1 -ne n2</code> |
* <code>[ n1 -ne n2 ]</code> |
||
vrai si n1 et n2 sont différents (''Not Equal''), |
|||
* <code>n1 -lt n2</code> |
* <code>[ n1 -lt n2 ]</code> |
||
vrai si n1 est strictement inférieur à n2 (''Less Than''), |
|||
* <code>n1 -le n2</code> |
* <code>[ n1 -le n2 ]</code> |
||
vrai si n1 est inférieur ou égal à n2 (''Less or Equal''), |
|||
* <code>n1 -gt n2</code> |
* <code>[ n1 -gt n2 ]</code> |
||
vrai si n1 est strictement supérieur à n2 (''Greater Than''), |
|||
* <code>n1 -ge n2</code> |
* <code>[ n1 -ge n2 ]</code> |
||
vrai si n1 est supérieur ou égal à n2 (''Greater or Equal''). |
|||
Pour les expressions : |
|||
* <code>! e</code>, vrai si e est faux ; |
|||
* <code>e1 -a e2</code>, vrai si e1 et e2 sont vrais ; |
|||
* <code>e1 -o e2</code>, vrai si e1 ou e2 est vrai. |
|||
== |
== Tests et logique == |
||
Ou comment introduire une alternative logique : |
|||
L'instruction <code>if</code> permet d'effectuer des opérations si une condition est réalisée. |
|||
* <code>[ ! e ]</code> |
|||
<pre> |
|||
vrai si e est faux. ! est la négation. |
|||
if condition |
|||
* <code>[ e1 -a e2 ]</code> |
|||
then instruction(s) |
|||
vrai si e1 et e2 sont vrais. -a ou le et logique (''And''). |
|||
fi |
|||
* <code>[ e1 -o e2 ]</code> |
|||
</pre> |
|||
vrai si e1 ou e2 est vrai. -o ou le ou lgogique (''Or''). |
|||
L'instruction <code>if</code> peut aussi inclure une instruction else permettant d'exécuter des instructions dans le cas ou la condition n'est pas réalisée. |
|||
<pre> |
|||
if condition |
|||
then instruction(s) |
|||
else instruction(s) |
|||
fi |
|||
</pre> |
|||
Il est bien sur possible d'immbriquer des <code>if</code> dans d'autres <code>if</code> et notamment des constructions telles que celle ci sont assez courantes : |
|||
<pre> |
|||
if condition1 |
|||
then instruction(s) |
|||
else |
|||
if condition2 |
|||
then instruction(s) |
|||
else |
|||
if condition3 |
|||
... |
|||
fi |
|||
fi |
|||
fi |
|||
</pre> |
|||
Pour permettre d'alléger ce type de code, ksh fournit un raccourci d'écriture : <code>elif</code>. Le code précédent pourrait être réécrit ainsi : |
|||
<pre> |
|||
if condition1 |
|||
then instruction(s) |
|||
elif condition2 |
|||
then instruction(s) |
|||
elif condition3 |
|||
... |
|||
fi |
|||
</pre> |
|||
== Test <code>case</code> == |
|||
L'instruction <code>case</code> permet de comparer une valeur avec une liste d'autres valeurs et d'exécuter un bloc d'instructions lorsque une des valeurs de la liste correpsond. |
|||
<pre> |
|||
case valeur_testee in |
|||
valeur1) instruction(s);; |
|||
valeur2) instruction(s);; |
|||
valeur3) instruction(s);; |
|||
... |
|||
esac |
|||
</pre> |
|||
Ce code est équivalent à : |
|||
<pre> |
|||
if [ valeur_teste = valeur1 ] |
|||
then instruction(s) |
|||
elif [ valeur_testee = valeur2 ] |
|||
then instruction(s) |
|||
elif [ valeur_testee = valeur3 ] |
|||
then instruction(s) |
|||
... |
|||
fi |
|||
</pre> |
|||
[[Catégorie:Programmation |
[[Catégorie:Programmation Bash (livre)]] |
||
Version du 8 mars 2008 à 14:48
Syntaxe du test
Deux syntaxes équivalentes permettent de tester des expressions :
[ expression ]
ou
test expression
Ces deux commandes renvoient un code de retour valant 0 si l'expression est vraie et 1 si l'expression est fausse.
Exemple :
$ [ 2 = 2 ] $ echo $? 0 $ [ 2 = 3 ] $ echo $? 1
La commande test fonctionne de manière complétement équivalente :
$ test 2 = 2 $ echo $? 0 $ test 2 = 3 $ echo $? 1
Tester une variable
Il est tout à fait possible de tester le contenu d'une variable avec les commandes test ou [ :
[ $a = toto ]
la substitution de la variable par sa valeur est alors effectuée est le test est vrai si la variable contient la valeur toto et faux sinon. Par contre, si la variable a n'est pas définie lors du test, la substitution de la ligne sera :
[ = toto ]
ce qui provoquera une erreur. Il est donc préférable de toujours protéger une variable lors d'un test soit avec des guillemets :
[ "$a" = toto ]
soit avec un préfixe :
[ x$a = xtoto ]
Tests sur les objets du système de fichiers
Les opérateurs de tests disponibles sont, pour les les objets du système de fichiers :
[ -e $FILE ]
vrai si l'objet désigné par $FILE existe dans le répertoire courant,
[ -s $FILE ]
vrai si l'objet désigné par $FILE existe dans le répertoire courant et si sa taille est supérieure à zéro,
[ -f $FILE ]
vrai si l'objet désigné par $FILE est un fichier dans le répertoire courant,
[ -r $FILE ]
vrai si l'objet désigné par $FILE est un fichier lisible dans le répertoire courant,
[ -w $FILE ]
vrai si l'objet désigné par $FILE est un fichier inscriptible dans le répertoire courant,
[ -x $FILE ]
vrai si l'objet désigné par $FILE est un fichier exécutable dans le répertoire courant,
[ -d $FILE ]
vrai si l'objet désigné par $FILE est un répertoire dans le répertoire courant.
Tests sur les chaînes de caractères
Les opérateurs de tests disponibles sont, pour les chaînes :
[ c1 = c2 ]
vrai si c1 et c2 sont égaux,
[ c1 != c2 ]
vrai si c1 et c2 sont différents,
[ -z c ]
vrai si c est la chaîne vide (Zero),
[ -n c ]
vrai si c n'est pas la chaîne vide (Non zero).
Tests sur les nombres
Pour les nombres :
[ n1 -eq n2 ]
vrai si n1 et n2 sont égaux (EQual),
[ n1 -ne n2 ]
vrai si n1 et n2 sont différents (Not Equal),
[ n1 -lt n2 ]
vrai si n1 est strictement inférieur à n2 (Less Than),
[ n1 -le n2 ]
vrai si n1 est inférieur ou égal à n2 (Less or Equal),
[ n1 -gt n2 ]
vrai si n1 est strictement supérieur à n2 (Greater Than),
[ n1 -ge n2 ]
vrai si n1 est supérieur ou égal à n2 (Greater or Equal).
Tests et logique
Ou comment introduire une alternative logique :
[ ! e ]
vrai si e est faux. ! est la négation.
[ e1 -a e2 ]
vrai si e1 et e2 sont vrais. -a ou le et logique (And).
[ e1 -o e2 ]
vrai si e1 ou e2 est vrai. -o ou le ou lgogique (Or).