L'icône rouge permet de télécharger chaque page du wiki visitée au format PDF et la grise au format ODT →

Différences

Ci-dessous, les différences entre deux révisions de la page.

--- doc:programmation:shells:page-man-bash-iii-les-operateurs-de-comparaison-numerique [14/02/2023 12:01]
agp91 [Comparaison numérique avec ((]
+++ doc:programmation:shells:page-man-bash-iii-les-operateurs-de-comparaison-numerique [20/02/2023 21:31]
agp91 [Conclusion sur les opérateurs lexicographiques et les opérateurs de comparaison numérique]
@@ Ligne 24: / Ligne 24: @@
 ===== Introduction =====
-Bash dispose de plusieurs commandes pour réaliser des comparaisons numériques:
+<note>
-  *La commande composée d'évaluation numérique **<nowiki>((</nowiki>**,
+Dans la page du manuel de bash, **les opérateurs des commandes de test** sont nommées __**primitives**__.
-  *La commande **[** (ou **test**),
+</note>
-  *Et la commande composée **<nowiki>[[</nowiki>**.
-===== Comparaison numérique avec (( =====
+Bash dispose de plusieurs commandes pour **réaliser des comparaisons numérique**.
-Syntaxe :
+  * Les commandes de test :
-<code>
+    * Les commandes internes **[** et **test**.
-(( expr1 OP expr2 ))
+    * Et la commande composée **<nowiki>[[</nowiki>**.
+  * Les commandes d'évaluation numériques :
+    * La commande composée **<nowiki>((</nowiki>** et la commande interne **let**.
-expr1 et expr2 sont sujets au développement des paramètres et au développement arithmétique.
+<note>
-Avec OP l'un des opérateurs donnés dans le tableau suivant.
+  * Les commandes **<nowiki>((</nowiki>** et **let** sont équivalentes.
-</code>
+  * Les commandes **[** et **test** sont équivalentes.
+  * Les commandes **[** et **test** sont disponibles dans leurs versions externe : **/usr/bin/[** et **/usr/bin/test**.
+    * Elles ont toutes les deux la même page de manuel (**man [** ou **man test**).
+  * Les commandes internes disposent de primitive que n'ont pas les commandes externes.
+</note>
+<note>
+__Rappels :__
-|Opérateurs de comparaison numérique de la commande <nowiki>((</nowiki>	||
+  *  Une commande de test renvoie le code de retour 0 (considérer comme vrai) lorsque le test réussi et 1 (considérer comme faux) lorsqu'il échoue.
-^ Opérateurs 			^ Description				^
+  *  Le code retour d'une commande est mémorisé dans le paramètre spécial $?.
-| '' == ''			| Comparaison d'un égalité              |
+  *  L'opérateur de contrôle **&&** exécute la commande suivante, si la commande précédente à renvoyée un code de retour égale à 0.
-| '' != ''			| Comparaison d'une différence          |
+  *  L'opérateur de contrôle **||** exécute la commande suivante, si la commande précédente à renvoyée un code de retour supérieur à 0.
-| '' > 	''			| Comparaison de plus grand que         |
+</note>
-| ''  >= ''			| Comparaison de plus grand ou égal que |
-| '' < ''			| Comparaison de plus petit que         |
-| ''<nowiki><=</nowiki> ''	| Comparaison de plus petit ou égal que |
+===== Comparaison numérique avec [ et [[ =====
+Les commandes de test dispose de 6 primitives binaires pour effectuer des comparaisons numériques.
+==== Syntaxe ====
+  * **test expr1 OP expr2**
+  * **[ expr1 OP expr2 ]**
+  * **<nowiki>[[</nowiki> expr1 OP <nowiki>expr2</nowiki> ]]**
+  * Avec :
+    * **Expr1** et **expr2** sont sujets au développement des paramètres.
+    * Avec la commande **<nowiki>[[</nowiki>**, **expr1** et **expr2** sont sujets à l’évaluation arithmétique. Les commandes **[** ou **test**, ne le permettent pas.
+    * **OP**, l'une des primitives du tableau suivant.
+|  Liste des primitives de comparaison numérique  ||
+^Primitives 	^ Retours			^
+|''-eq ''	| est égal à			|
+|''-ne ''	| n'est pas égal à		|
+|''-gt ''	| est plus grand que		|
+|''-ge ''	|est plus grand ou égal à	|
+|''-lt ''	|est plus petit que 		|
+|''-le ''	|est plus petit ou égal à	|
+==== Exemples ====
-==== Exemples dans le terminal ====
 <code user>
-(( 42 == 42 ))			# Est-ce que 42 est égale à 42.
+[ 25 -eq 20 ]	# Teste si 25 est égale à 20
-echo $?				# Affiche le code de retour.
+echo $?
+</code><code>
+
+</code>
-nombre1=12
+<code user>
-nombre2=13
+var1=17
-(( $nombre1 > $nombre2 ))	# Est-ce-que nombre1 (12) est strictement supérieur au nombre2 (13).
+var2=18
-echo $?				# Affiche le code de retour.
+echo "$var1 est-il plus grand que $var2 : $([ $var1 -gt $var2 ]; echo $?)"
+echo "$var1 est-il plus petit que $var2 : $([[ $var1 -lt $var2 ]]; echo $?)"
+echo "$var1 est-il différent de $var2 : $(test $var1 -ne $var2 ; echo $?)"
-unset nombre1 nombre2		# Suppression des paramètres nombre1 et nombre2
+unset var1 var2
+</code><code>
+est-il plus grand que 18 : 1
+est-il plus petit que 18 : 0
+est-il différent de 18 : 0
 </code>
-<file config retour de la commande>
-</file>
-Les paramètres peuvent être transmis sans $ (Sauf les paramètres positionnels et les paramètres spéciaux)\\
+Copions le code ci-dessous dans le fichier **mon_script**.\\
-Les espaces peuvent être omis.
+Puis exécutons le avant de le supprimer.
-<code user>
+<code bash mon_script>
-n1=42
+#!/bin/bash
-n2=24
+a=2 ; b=1
-(( n1 > n2 )) && echo "$n1 > $n2" || echo "$n1 < $n2"
+if [ "$a" -gt "$b" ] ; then
+	echo "$a est plus grand que $b"
+fi
-if ((n1>n2))
+if test 100 -gt 99
 then
-	echo "$n1 est supérieur à $n2"
+	echo "vrai"   #réponse : vrai
 else
-	echo "$n1 est inférieur à $n2"
+	echo "faux"
 fi
+</code><code user>
+bash mon_script
-unset n1 n2
+rm -f mon_script
-</code>
+</code><file>
-<file config retour de la commande>
+est plus grand que 1
-> 24
+vrai
-est supérieur à 24
+'mon_script' supprimé
 </file>
-Le développement des opérandes doivent être des valeurs numérique.\\
+==== Particularités de la commande [[ ====
-Mais comme nous l'avons vu au dessus, les paramètre n'ont pas besoin du meta caractère $ pour être développé.\\
-Un simple mot sera alors interprété comme un paramètre.\\
-Si ce paramètre n'existe pas, son développent retournera 0.
-rappel : L'option -e de la commande echo permet de développer les caractères protégés, (ici \n qui se développe en saut de ligne). Le développement des caractères protégés se réalisent entre guillemets doubles. Sans guillemets, il est nécessaire de protégé le caractère de protection (\\n).
+Seule la commande **<nowiki>[[</nowiki>** permet de tester une expression arithmétique.
-<code>
-echo ==========
-(("Du texte" >= 0))
-echo -e "((\"Du texte\" >= 0)) revoie le code de retour $? \n"
-(("DuTexte" == 0))
+<code user>
-echo -e "((\"DuTexte\" == 0)) revoie le code de retour $? \n"
+test 21+21 -eq 42 ; echo -e $?\\n
-n="Du texte"
+[ 21*2 -eq 42 ] ; echo -e $?\\n
-((n>=0))
-echo -e 'Avec n="Du texte" ; ((n>=0)) renvoie le code retour' $? \\n
-n="Dutexte"
+[[ 84-42 -eq 42 ]] ; echo $?
-((n!=0))
+</code><code>
-echo -e 'Avec n="DuTexte" ; ((n!=0)) renvoie le code retour' $? \\n
+bash: test: 21+21 : nombre entier attendu comme expression
-unset n
+bash: [: 21*2 : nombre entier attendu comme expression
+
 </code>
-<file config retour des commandes>
+<note>
-==========
+Lorsqu'une commande interne **le code de retour renvoie 2**, cela signifie un mauvais usage de cette commande.
-bash: ((: Du texte >= 0 : erreur de syntaxe dans l'expression (le symbole erroné est « texte >= 0 »)
+</note>
-(("Du texte" >= 0)) revoie le code de retour 1
-(("DuTexte" == 0)) revoie le code de retour 0
+Elle est aussi la seule à accepter les chaînes vides qui sont alors évaluées à **0**.
-bash: ((: Du texte : erreur de syntaxe dans l'expression (le symbole erroné est « texte »)
+<code user>
-Avec n="Du texte" ; ((n>=0)) renvoie le code retour 1
+[[ 0 -eq "" ]] ; echo $?
+[[ "" -ne 0 ]] ; echo $?
+[[ "" -eq "" ]] ; echo $?
+</code><code>
+
+
+
+</code>
-Avec n="DuTexte" ; ((n!=0)) renvoie le code retour 1
+Idem pour les chaînes de caractères sans espace (mots). Un mot est substitué par **0**.
-</file>
-==== Exemple dans un script ====
+<code user>
+[[ mot -eq 0 ]] ; echo $?
+[[ 0 -ne mot ]] ; echo $?
+[[ mot1 -eq mot2 ]] ; echo $?
+</code><code>
+
+
+
+</code>
+<note important>
+Attention :
 <code bash mon_script>
 #!/bin/bash
-a=8 ; b=2
+var1=8
-if (( "$a" < "$b" )) ; then
+var2=7
-  echo " $a < $b "
+if test "$e" -gt "$f" ; then
-else
+  echo " $var1 est plus grand que $var2 "
-  echo "$a n'est pas inférieur à $b"
 fi
+printf \\n
+test 8 -gt 7 && echo "$var1 est plus grand que $var2"
 </code>
 <code user>
 bash mon_script
-echo $?
+rm -v mon_script
 </code>
 <file config retour de la commande>
- n'est pas inférieur à 2
+mon_script: ligne 4 : test:  : nombre entier attendu comme expression
+est plus grand que 7
+'mon_script' supprimé
 </file>
+</note>
-Remarque : L’exécution du script retournera toujours 0 (true), car le code de retour renvoyé est celui de la dernière commande exécutée, qui est echo (voir [[doc:programmation:shells:script-bash-etat-de-sorie-et-les-tests#utiliser-la-commande-exit|utilisation de la commande exit]]).
+==== Mauvais usages ====
-<note important>
+Le caractère **$** est obligatoire pour développer les paramètres. Sans, ils sont interprétés comme des mots.
-Attention à la confusion avec les tests sur les chaînes de caractères !
-<code bash script>
+Avec la commande **[** (ou **test**), les chaînes vides ou les mots sont à proscrire.
-#!/bin/bash
-a=23
+<code user>
-b=4
+test 42 -eq "" ; echo $?
-if (( "$a" < "$b" )) ; then
+[ 42 -lt "" ] ; echo $?
-	echo "$a > $b"
+echo =====
-else
+test "" -gt 42 ; echo $?
-	echo "aïe : $a < $b ???"
+[ "" -ge 42 ] ; echo $?
-fi
+</code><code>
-echo " "
+bash: test:  : nombre entier attendu comme expression
-c="23"
+bash: [:  : nombre entier attendu comme expression
-d="24"
-if test "$c" > "$d" ; then
+=====
-  echo "Attention ! incohérence "$c" > "$d" car avec test et crochets,
+bash: test:  : nombre entier attendu comme expression
-        il s'agit de tests sur les chaînes de caractères."
-fi
+bash: [:  : nombre entier attendu comme expression
-echo " "
-e="26"
-f="25"
-if [ "$e" > "$f" ] ; then
-  echo "De même, Attention ! "$e" n'est pas plus grand que "$f"
-	mais après "$f" selon l'ordre des caractères ASCII !!!"
-fi
 </code>
-Retour:  8-O
->Remarquez l'incohérence : ''23 > 24''
+<code user>
->Il s'agit de tests sur les chaînes de caractères, donc il ne s'agit pas de plus petit
+test mot -eq 0	; echo $?
->ou de plus grand, mais d'avant et après, selon l'ordre des caractères ''ASCII''(([[doc:programmation:shells:bash-vii-globs-etendus-regex#index-2]])).
+[ 0 -eq mot ]	; echo $?
+test O -le 0	; echo $?
+[ "mot" -ge 0 ]	; echo $?
+echo $?
+</code><code>
+bash: test: mot : nombre entier attendu comme expression
+
+bash: [: mot : nombre entier attendu comme expression
+
+bash: test: O : nombre entier attendu comme expression
+
+bash: [: mot : nombre entier attendu comme expression
+
+</code>
->De même, attention 26 n'est pas plus grand que 25 !
+Avec **[** (ou **test**) et **<nowiki>[[</nowiki>**, les opérandes ne peuvent être des chaînes de caractères qui comportent des espaces.
->Mais 26 est après 25.
+<code user>
+test "Du texte" -eq 0	; echo $?
+[ 0 -ge "Du texte" ]	; echo $?
+[[ "Du texte" -ge 0 ]]	; echo $?
+</code><code>
+bash: test: Du texte : nombre entier attendu comme expression
+bash: [: Du texte : nombre entier attendu comme expression
+bash: [[: Du texte : erreur de syntaxe dans l'expression (le symbole erroné est « texte »)
+</code>
+<note >
+Il est remarquable que le test ''<nowiki>[[ "Du texte" -ge 0 ]]</nowiki>'', ne renvoie pas le **code de retour 2**.\\
+Pourtant il s'agit bien d'un mauvais usage de la commande ''<nowiki>[[</nowiki>''.
 </note>
-===== Comparaison numérique avec [ et [[ =====
+Les deux opérandes sont obligatoires.
-La comparaison numérique peut aussi se réalisée avec les commandes **[** (ou **test**) et **<nowiki>[[</nowiki>**.
-Syntaxe :
+<code user>
-<code>
+test 42 -eq ; echo $?
-[ expr opérateur expr ]
+[ 42 -lt ] ; echo $?
-[[ expr opérateur expr ]]
+[[ 42 -ne ]]
+echo $?
+echo =====
+test -gt 42 ; echo $?
+[ -ge 42 ] ; echo $?
+[[ -le 42 ]]
+echo $?
+</code><code>
+bash: test: 42 : opérateur unaire attendu
+
+bash: [: 42 : opérateur unaire attendu
+
+bash: argument « ]] » inattendu pour l'opérateur binaire conditionnel
+bash: erreur de syntaxe près de « ]] »
+
+=====
+bash: test: -gt : opérateur unaire attendu
+
+bash: [: -ge : opérateur unaire attendu
+
+bash: opérateur binaire conditionnel attendu
+bash: erreur de syntaxe près de « 42 »
 </code>
-| Opérateurs de comparaison des commande [ et <nowiki>[[</nowiki> ||
+Ainsi que les espaces.\\
-^Caractères   ^  Significations         ^
+Lorsqu'il n'y pas d'espaces entre les opérandes et l'opérateur, l'ensemble est considéré comme une chaîne de caractères\\
-|''-eq ''        | est égal à               |
+Puisque la chaîne est non vide, le test n'échoue pas.
-|''-ne ''        | n'est pas égal à         |
-|''-gt ''        | est plus grand que       |
-|''-ge ''        |est plus grand ou égal à  |
-|''-lt ''        |est plus petit que        |
-|''-le ''        |est plus petit ou égal à  |
-===Exemples dans le terminal ===
 <code user>
-[ 25 -eq 20 ]
+test 420-ne420	; echo $?
-echo $?
+[ 420-gt42 ]	; echo $?
+[[ 42-lt420 ]]	; echo $?
+</code><code>
+
+
 </code>
-<file config retour de la commande>
-
-</file>
-== Ou encore : ==
+Ne pas utiliser les opérateurs **<** et **>** avec **[** (ou **test**) et **<nowiki>[[</nowiki>** pour réaliser des comparaisons numériques.\\
+Car avec ces commandes, ces opérateur sont des opérateurs de comparaison lexicographique.\\
+(voir [[https://debian-facile.org/doc:programmation:shells:la-page-man-bash-ii-les-operateurs-lexicographiques|Bash : Les opérateurs sur chaînes]]).
+__Rappel :__ Avec **[** (ou **test**), les opérateurs **<** et **>** s'utilisent protégés (voir [[https://debian-facile.org/atelier:chantier:bash-comparaison-lexicographique-des-chaines#tests-avec1|Bash, comparaison lexicographique avec [ ou test]]).
 <code user>
-var1=17
+test 425 \> 4242 ; echo $?
-var2=18
+[ 426 \> 4242 ]		; echo $?
-[ "$var1" -gt "$var2" ]
+[[ 4242 < 427 ]]	; echo $?
-echo $?
 </code>
-== OU mieux : ==
+<file config retour des commandes>
+
+
+
+</file>
+Lexicographiquement 425, 426 et 427 sont supérieurs (placés après dans l'ordre lexicographique), mais sont inférieurs (plus petits) numériquement à 4242.
+===== Comparaison numérique avec (( =====
+Syntaxe :
+<code>
+let <expr1><OP><expr2>
+let "<expr1> <OP> <expr2>"
+(( <expr1> <OP> <expr2> ))
+<expr1> et <expr2> sont sujets au développement des paramètres et à l’évaluation arithmétique.
+Avec <OP> l'un des opérateurs donnés dans le tableau suivant.
+</code>
+__Remarques :__ Les commandes **let** et **<nowiki>((</nowiki>** sont équivalentes.
+|  Opérateurs de comparaison numérique des commandes let et <nowiki>((</nowiki>  	||
+^ Opérateurs 			^ Description				^
+| '' == ''			| Comparaison d'une égalité              |
+| '' != ''			| Comparaison d'une différence          |
+| '' > 	''			| Comparaison de plus grand que         |
+| ''  >= ''			| Comparaison de plus grand ou égal que |
+| '' < ''			| Comparaison de plus petit que         |
+| ''<nowiki><=</nowiki> ''	| Comparaison de plus petit ou égal que |
+La commande **let** ne supporte qu'un seul argument.\\
+Si l'expression arithmétique à évaluer comporte des espaces, l'expression doit être protégée par des guillemets simples ou doubles.\\
+Si l'expression n'est pas protégée, les opérateurs commençant par **<** ou **>** doivent être protégés\\
+(Voir plus bas : [[https://debian-facile.org/doc:programmation:shells:page-man-bash-iii-les-operateurs-de-comparaison-numerique#mauvais-usages|Mauvais usages]].)
+==== Exemples dans le terminal ====
 <code user>
-test 100 -gt 99 && echo "vrai" || echo "faux"  # retour : vrai
+(( 42 == 42 ))			# Est-ce que 42 est égale à 42.
+echo $?				# Affiche le code de retour.
+let 24\>=24			# Est-ce que 24 est supérieur ou égale à 24
+echo $?				# Affiche le code de retour.
 </code>
+<file config retour des commandes>
+</file>
 <code user>
-test 100 -lt 99 && echo "vrai" || echo "faux"   # retour : faux
+nombre1=12
+nombre2=13
+(( $nombre1 > $nombre2 ))	# Est-ce-que nombre1 (12) est strictement supérieur au nombre2 (13).
+echo $?				# Affiche le code de retour.
+let "$nombre1 != $nombre2"	#Est-ce-que nombre1 (12) est différent du nombre2 (13)
+echo $?				# Affiche le code de retour.
+unset nombre1 nombre2		# Suppression des paramètres nombre1 et nombre2
 </code>
+<file config retour des commandes>
+</file>
+Les paramètres peuvent être transmis sans **$** (Sauf les paramètres positionnels et les paramètres spéciaux).
 <code user>
-[ 5 -eq 5 ]; echo $?
+n1=42
+n2=24
+(( n1 > n2 )) && echo "$n1 > $n2" || echo "$n1 < $n2"
+let n1==n2 && echo "$n1 est égale à $n2" || echo "$n1 est différent de $n2"
+unset n1 n2
 </code>
+<file config retour des commandes>
+> 24
+est différent de 24
+</file>
+Comme nous l'avons vu au dessus, les paramètres n'ont pas besoin du caractère **$** pour être développés.\\
+Un simple mot sera alors interprété comme un paramètre.\\
+Si ce paramètre n'existe pas, le mot sera substitué par **0**.
-<file config retour de la commande>
+<code user>
+(("mot" == 0))
+echo '(("mot" == 0)) revoie le code de retour' $?
+let "mot <= 0"
+echo 'let "mot <= 0" revoie le code de retour' $?
+n="mot"
+((n!=0))
+echo -e "Avec n=\"$n\" ; ((n!=0)) renvoie le code de retour $?"
+let n==0
+echo -e "Avec n=\"${n}\" ; let n==0 renvoie le code de retour $?"
+unset n
+</code>
+<file config retour des commandes>
+(("mot" == 0)) revoie le code de retour 0
+let "mot <= 0" revoie le code de retour 0
+Avec n="mot" ; ((n!=0)) renvoie le code de retour 1
+Avec n="mot" ; let n==0 renvoie le code de retour 0
 </file>
->car l'expression est vraie
-=== Exemple avec la commande test dans le terminal:===
+Si un paramètre existe mais que sa valeur est vide, son développement retournera 0.
 <code user>
-test 17 -gt 11 ; echo $?
+n=
+((n==0))	; echo $?
+let 'n != 0'	; echo $?
+unset n
 </code>
+<file config retour des commandes>
+</file>
+Avec la commande **<nowiki>((</nowiki>**, les espaces ne sont pas obligatoires.
+<code user>
+n1=4242
+n2=2424
+if ((n1>n2))
+then
+	echo "$n1 est supérieur à $n2"
+else
+	echo "$n1 est inférieur à $n2"
+fi
+unset n1 n2
+</code>
 <file config retour de la commande>
+est supérieur à 2424
 </file>
-De même :
+==== Mauvais usages ====
+Avec la commande **let**, si l'expression à évaluer n'est pas protégée,\\
+Les espaces entre les opérandes et l'opérateur ne sont pas supportés.
 <code user>
-var1=17 ; var2=11 ; test "$var1" -gt "$var2" ; echo $?
+let -42 \< 0	; echo $?
+let 0 == 0	; echo $?
 </code>
+<file config retour des commandes>
-<file config retour de la commande>
+bash: let: < : erreur de syntaxe : opérande attendu (le symbole erroné est « < »)
+bash: let: == : erreur de syntaxe : opérande attendu (le symbole erroné est « == »)
 </file>
-===Exemple avec les crochets dans un script:===
-<code bash mon-script>
-#!/bin/bash
+Avec la commande **let**, si l'expression à évaluer est protégé par des guillemets simples,\\
-a=2 ; b=1
+Les paramètres sont développés uniquement s'ils ne disposent pas du caractère **$**.\\
-if [ "$a" -gt "$b" ] ; then
+S'il est fourni, une erreur est renvoyée.
-        echo "$a est plus grand que $b"
-fi
+<code user>
+n=42
+let 'n==42'	; echo $?
+let '$n > 42'	; echo $?
 </code>
+<file config retour des commandes>
+bash: let: $n == 42 : erreur de syntaxe : opérande attendu (le symbole erroné est « $n == 42 »)
+</file>
+Avec la commande **let**, si l'expression à évaluer n'est pas protégée, les opérateurs **<**, **<nowiki><=</nowiki>**, **>** et **>=** doivent être protégés.\\
+Les trois types de protection (**\**, entre guillemets simples **<nowiki>''</nowiki>** et entre guillemets doubles **""** fonctionnent.\\
+S'ils ne sont pas protégés, les opérateurs **<** et **>** sont des opérateurs de redirection.\\
+Démonstration :
+__Rappels :__\\
+La commande **printf "\n"**, renvoit un saut de ligne.\\
+La commande **echo -n**, n'ajoute pas de saut ligne à la fin de son retour.
 <code user>
-./mon-script :
+p=$PWD
+mkdir /tmp/test_let
+cd /tmp/test_let
+let 240>420	; echo $?
+let 241>=421	; echo $?
+let 243<423	; echo $?
+let 244<=424	; echo $?
+printf "\n"
+echo -n "ls :"
+ls
+printf "\n"
+cd $p
+rm -rfv /tmp/test_let
 </code>
-<file config retour de la commande>
+<file config retour des commandes>
- est plus grand que 1
+bash: let: une expression est attendue
+
+bash: let: une expression est attendue
+
+bash: 423: Aucun fichier ou dossier de ce type
+
+bash: =424: Aucun fichier ou dossier de ce type
+
+ls : 420  '=421'
+'/tmp/test_let/=421' supprimé
+'/tmp/test_let/420' supprimé
+répertoire '/tmp/test_let' supprimé
 </file>
-===Exemple avec la commande test dans un script:===
+Les opérateurs **>** et **>=** ont créé respectivement les fichiers **420** et **=421**.\\
+Les opérateurs **<** et **<nowiki><=</nowiki>** ont recherché les fichiers **423** et **=424**, sans les trouver.
-<code bash mon-script>
+Les opérateurs de comparaison sont des opérateurs binaires, ils attendent donc 2 arguments (ou opérandes).\\
-if test 100 -gt 99
+Les commande **<nowiki>((</nowiki>** et **let** retournent une erreur s'il manque un opérande.
-then
+<code>
-	echo "vrai"   #réponse : vrai
+(( == 0))	; echo $?
-else
+let 0>=		; echo $?
-	echo "faux"
+echo =====
-fi
+(( 42 < ""))	; echo $?
+let ""!=24	; echo $?
 </code>
+<file config retour des commandes>
+bash: ((: == 0 : erreur de syntaxe : opérande attendu (le symbole erroné est « == 0 »)
+bash: let: une expression est attendue
+=====
+bash: ((: 42 <  : erreur de syntaxe : opérande attendu (le symbole erroné est « <  »)
+bash: let: !=24 : erreur de syntaxe : opérande attendu (le symbole erroné est « !=24 »)
+</file>
+Les opérandes ne peuvent être des chaînes de caractères contenant des espaces.
+__Rappel :__ L'option **-e** de la commande **echo** permet de développer les caractères protégés, (ici **\n** qui se développe en saut de ligne).\\
+Le développement des caractères protégés se réalisent entre guillemets doubles.\\
+Sans guillemets, il est nécessaire de protéger le caractère de protection (**\\n**).
 <code user>
-./mon-script
+(("Du texte" >= 0))
+echo -e '* (("Du texte" >= 0)) renvoie le code de retour' $?\\n
+let 424\>"Du texte"
+echo -e '* let 424\>"Du texte" renvoie le code de retour' $?\\n
+n="Du texte"
+((0<=n))
+echo -e "* Avec n=\"$n\" ; ((0<=n)) renvoie le code retour $?\n"
+let n==0
+echo "* Avec n=\"${n}\" ; let n==0 renvoie le code retour $?"
+unset n
 </code>
-<file config retour de la commande>
+<file config retour des commandes>
-vrai
+bash: ((: Du texte >= 0 : erreur de syntaxe dans l'expression (le symbole erroné est « texte >= 0 »)
+* (("Du texte" >= 0)) renvoie le code de retour 1
+bash: let: 424>Du texte : erreur de syntaxe dans l'expression (le symbole erroné est « texte »)
+* let 424\>"Du texte" renvoie le code de retour 1
+bash: ((: Du texte : erreur de syntaxe dans l'expression (le symbole erroné est « texte »)
+* Avec n="Du texte" ; ((0<=n)) renvoie le code retour 1
+bash: let: Du texte : erreur de syntaxe dans l'expression (le symbole erroné est « texte »)
+* Avec n="Du texte" ; let n==0 renvoie le code retour 1
 </file>
-<note important>
+<note>
-Attention :
+Remarquons que les commandes **let** et **<nowiki>((</nowiki>** renvoient le code de retour **1** quand elles sont en erreur. Ce n'est pas la norme pour une commande interne de bash. Le code de retour devrait être **2**.
-<code bash mon-script>
+</note>
+==== Exemple dans un script ====
+Copions le code ci-dessous dans un fichier nommé mon_script.
+<code bash mon_script>
 #!/bin/bash
-var1=8
+a=8 ; b=2
-var2=7
+if (( "$a" < "$b" )) ; then
-if test "$e" -gt "$f" ; then
+  echo "$a < $b"
-  echo " $var1 est plus grand que $var2 "
+else
-fi
+  echo "$a n'est pas inférieur à $b"
-echo " "
-if test 8 -gt 7 ; then
-  echo " $var1 est plus grand que $var2 "
 fi
 </code>
+Et exécutons le.
 <code user>
-./mon-script
+bash mon_script
+echo $?
+rm -v mon_script
 </code>
 <file config retour de la commande>
- : ligne 18 : test:  : nombre entier attendu comme expression
+ n'est pas inférieur à 2
-est plus grand que 7
+'mon_script' supprimé
 </file>
-</note>
-=====Conclusion sur les opérateurs lexicographiques et les opérateurs de comparaison numérique=====
-====Yep, plus de confusions ! ====
-<note>
-Nous avons vu :\\
-  * qu'il y a deux mécanismes pour effectuer des tests, la paire de crochets et la commande test;
+__Remarque :__ L’exécution du script renverra toujours **0** (true), car le code de retour renvoyé est celui de la dernière commande exécutée, qui est **echo**.\\
+(voir [[doc:programmation:shells:script-bash-etat-de-sorie-et-les-tests#utiliser-la-commande-exit|utilisation de la commande exit]]).
-  * qu'à chaque mécanisme sa syntaxe :
+==== Exemple dans une fonction ===
-<code>
-$ test -f /etc/gaga
-</code>
-Ou
+Nous créons ici une fonction (test_si_négatif) qui teste si une expression numérique ou arithmétique est négative.
-<code>
+__Rappel :__ La commande **return** est identique à la commande **exit** (**return** s'utilise dans une fonction, **exit** dans un script).
-$ [ -f /etc/gaga ]
-</code>
-(Si le fichier /etc/gaga existait, //le code de retour// serait 0.\\ Voir la commande exit et son utilisation dans les scripts.)
-  * qu'il était possible de faire des tests avec commande test ou les crochets sur [[doc:programmation:shells:la-page-man-bash-ii-les-operateurs-lexicographiques#caracteres-de-comparaison-sur-les-chaines-de-caracteres|les chaînes de caractères]] ; et [[doc:programmation:shells:la-page-man-bash-ii-les-operateurs-lexicographiques#tests-sur-les-fichiers|les fichiers]].
+<code user>
+test_si_négatif() {
+	# Test_si_négatif <expression>
+	# Retourne le code de retour 0 si <experssion> est négative
+	# Retourne le code de retour 1 si <experssion> est positive
+	# Retourne le code de reour 2 si la fonction est mal utilisée
+	local rc=2				# Initialise le paramètre rc avec la valeur 2
+	if (( $# == 0 ))			# Test si le nombre d'argument est 0
+	then						# Si oui,
+		echo "Argument manquant" >&2		# Retourne un message sur le canal d'erreur
+	elif (( $# > 1 ))			# Si non, test si le nombre d'argument est > à 1
+	then						# Si oui
+		echo "Trop d'arguments" >&2		# Retourne un message sur le canal d'erreur.
+	elif (($1 >= 0))			# Si non, test si l'argument est positif ou égale à 0
+	then						# Si oui,
+		rc=1					# Affecte 1 au paramètre rc
+	elif (($1 < 0))			# Si non, test si l'argument est négatif
+	then						# Si oui,
+		rc=0					# Affecte 0 au paramètre rc
+	fi
+	return $rc				# Affecte $rc au code retour
+}
-  * que, pour des comparaisons sur [[doc:programmation:shells:page-man-bash-iii-les-operateurs-de-comparaison-numerique|les nombres]] on utilise :
+test_si_négatif		; echo -e $?\\n
-soit les doubles parenthèses avec les opérateurs booléens :
+test_si_négatif 42	; echo $?
-<code>
+test_si_négatif -42	; echo $?
- ==    !=   <	>   >=   <=
+test_si_négatif 42-84	; echo $?
-</code>
-soit les crochets (ou la commande "test") avec les opérateurs :
+unset test_si_négatif
-<code>
--eq   -ne   -gt   -ge   -lt   -le
 </code>
-  * qu'on utilise exclusivement les opérateurs ''-eq'' ; ''-ne'' ; ''-gt'' ; ''-ge'' ; ''-lt'' ; ''-le'' sur les nombres mais pas sur les chaînes de caractères ;
+Le troisième usage de notre fonction montre que la commande **<nowiki>((</nowiki>** évalue une expression arithmétique avant de la tester.
-  * qu'enfin il ne faut pas confondre pas avec les opérateurs précédents, les options qu'on utilise exclusivement pour tester les fichiers :''-e''  ; ''-d''; ''-f'' ; ''-L'' ; ''-r'' ; ''-w'' ; ''-x'' ; $fichier1 ''-nt'' $fichier2 ; $fichier1 ''-ot'' $fichier2
+<file config retour des commandes>
+Argument manquant
-Plein d'exemples dans ce wiki en anglais : [[http://wiki.bash-hackers.org/commands/classictest]]
-</note>
+
+</file>
-:-D
 =====Pour aller plus loin : les opérateurs logiques.=====

doc/programmation/shells/page-man-bash-iii-les-operateurs-de-comparaison-numerique.txt · Dernière modification: 30/09/2023 23:06 (modification externe)

Debian-facile

Différences

Pied de page des forums