Debian
Debian-France
Debian-Facile
Debian-fr.org
Forum-Debian.fr
Debian ?
Communautés
Vous n'êtes pas identifié(e).
L'icône rouge permet de télécharger chaque page du wiki visitée au format
PDF et la grise au format ODT →
Ci-dessous, les différences entre deux révisions de la page.
| Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente Prochaine révision Les deux révisions suivantes | ||
|
doc:programmation:shells:page-man-bash-iii-les-operateurs-de-comparaison-numerique [14/02/2023 11:53] agp91 [Comparaison numérique avec ((] |
doc:programmation:shells:page-man-bash-iii-les-operateurs-de-comparaison-numerique [15/02/2023 21:52] ubub [Comparaison numérique avec ((] |
||
|---|---|---|---|
| Ligne 24: | Ligne 24: | ||
| ===== Introduction ===== | ===== Introduction ===== | ||
| - | Bash dispose de plusieurs commandes pour réaliser des comparaisons numériques: | + | En interne, bash dispose de plusieurs commandes pour réaliser des comparaisons numériques: |
| - | *La commande composée d'évaluation numérique **<nowiki>((</nowiki>**, | + | *La commande composée **<nowiki>((</nowiki>** et la commande **let**. |
| - | *La commande **[** (ou **test**), | + | *Les commandes **[** et **test**. |
| *Et la commande composée **<nowiki>[[</nowiki>**. | *Et la commande composée **<nowiki>[[</nowiki>**. | ||
| + | |||
| + | Les commandes **[** et **test** sont disponibles dans leurs versions externe : **/usr/bin/[** et **/usr/bin/test**. | ||
| + | |||
| + | __Rappels :__ | ||
| + | * Une commande de test renvoie le code de retour true (0) lorsque le test réussi et false (1) lorsqu'il échoue. | ||
| + | * Le code retour d'une commande est mémorisé dans le paramètre spécial **$?**. | ||
| + | * L'opérateur **<nowiki>&&</nowiki>** exécute la commande suivante, si la commande précédente à renvoyée le code retour true (égale à 0). | ||
| + | * L'opérateur **<nowiki>||</nowiki>** exécute la commande suivante, si la commande précédente à renvoyée le code retour false (différent de 0). | ||
| + | |||
| ===== Comparaison numérique avec (( ===== | ===== Comparaison numérique avec (( ===== | ||
| Ligne 33: | Ligne 42: | ||
| Syntaxe : | Syntaxe : | ||
| <code> | <code> | ||
| - | (( expr1 opérateur expr2 )) | + | let <expr1><OP><expr2> |
| - | expr1 et expr2 est sujet au développement des paramètres et au développement arithmétique. | + | (( <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. | ||
| + | Avec la commande **let**, les opérateurs commençant par **<** ou **>** doivent être protégés (voir plus bas : Mauvais usages). | ||
| </code> | </code> | ||
| + | __Remarque :__ Les commandes **let** et **<nowiki>((</nowiki>** sont pratiquement équivalentes (voir les différences plus bas Mauvais usages). | ||
| - | |Opérateurs de comparaison numérique de la commande <nowiki>((</nowiki> || | + | | Opérateurs de comparaison numérique de la commande <nowiki>((</nowiki> || |
| ^ Opérateurs ^ Description ^ | ^ Opérateurs ^ Description ^ | ||
| - | | '' == '' | Comparaison d'un égalité | | + | | '' == '' | Comparaison d'une égalité | |
| | '' != '' | Comparaison d'une différence | | | '' != '' | Comparaison d'une différence | | ||
| | '' > '' | Comparaison de plus grand que | | | '' > '' | Comparaison de plus grand que | | ||
| Ligne 46: | Ligne 60: | ||
| | '' < '' | Comparaison de plus petit que | | | '' < '' | Comparaison de plus petit que | | ||
| | ''<nowiki><=</nowiki> '' | Comparaison de plus petit ou égal que | | | ''<nowiki><=</nowiki> '' | Comparaison de plus petit ou égal que | | ||
| - | |||
| ==== Exemples dans le terminal ==== | ==== Exemples dans le terminal ==== | ||
| + | |||
| <code user> | <code user> | ||
| (( 42 == 42 )) # Est-ce que 42 est égale à 42. | (( 42 == 42 )) # Est-ce que 42 est égale à 42. | ||
| echo $? # Affiche le code de retour. | 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> | ||
| + | 0 | ||
| + | 0 | ||
| + | </file> | ||
| + | <code user> | ||
| nombre1=12 | nombre1=12 | ||
| nombre2=13 | nombre2=13 | ||
| (( $nombre1 > $nombre2 )) # Est-ce-que nombre1 (12) est strictement supérieur au 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. | echo $? # Affiche le code de retour. | ||
| unset nombre1 nombre2 # Suppression des paramètres nombre1 et nombre2 | unset nombre1 nombre2 # Suppression des paramètres nombre1 et nombre2 | ||
| </code> | </code> | ||
| - | <file config retour de la commande> | + | <file config retour des commandes> |
| - | 0 | + | |
| 1 | 1 | ||
| + | 0 | ||
| </file> | </file> | ||
| - | Les paramètres peuvent être transmis sans $ (Sauf les paramètres positionnels et les paramètres spéciaux)\\ | + | Les paramètres peuvent être transmis sans **$** (Sauf les paramètres positionnels et les paramètres spéciaux). |
| - | Les espaces peuvent être omis. | + | |
| <code user> | <code user> | ||
| Ligne 72: | Ligne 95: | ||
| n2=24 | n2=24 | ||
| (( n1 > n2 )) && echo "$n1 > $n2" || echo "$n1 < $n2" | (( 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> | ||
| + | 42 > 24 | ||
| + | 42 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, son développement renverra **0**. | ||
| + | |||
| + | <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> | ||
| + | |||
| + | Avec la commande **<nowiki>((</nowiki>**, les espaces ne sont pas obligatoires. | ||
| + | <code user> | ||
| + | n1=4242 | ||
| + | n2=2424 | ||
| if ((n1>n2)) | if ((n1>n2)) | ||
| then | then | ||
| Ligne 83: | Ligne 143: | ||
| </code> | </code> | ||
| <file config retour de la commande> | <file config retour de la commande> | ||
| - | 42 > 24 | + | 4242 est supérieur à 2424 |
| - | 42 est supérieur à 24 | + | |
| </file> | </file> | ||
| - | Le développement des opérandes doivent être des valeurs numérique.\\ | + | ==== Mauvais usages ==== |
| - | 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). | + | La commande **let** ne supporte pas les espaces entre les opérandes et l'opérateur. |
| - | <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" | + | let -42 \< 0 ; echo $? |
| + | let 0 == 0 ; echo $? | ||
| + | </code> | ||
| + | <file config retour des commandes> | ||
| + | bash: let: < : erreur de syntaxe : opérande attendu (le symbole erroné est « < ») | ||
| + | 1 | ||
| + | bash: let: == : erreur de syntaxe : opérande attendu (le symbole erroné est « == ») | ||
| + | 1 | ||
| + | </file> | ||
| - | n="Du texte" | + | Avec la commande **let**, les opérateurs **<**, **<nowiki><=</nowiki>**, **>** et **>=** doivent être protégés.\\ |
| - | ((n>=0)) | + | |
| - | echo -e 'Avec n="Du texte" ; ((n>=0)) renvoie le code retour' $? \\n | + | |
| - | n="Dutexte" | + | Les trois types de protection (**\**, entre guillemets simples **<nowiki>''</nowiki>** et entre guillemets doubles **""** fonctionnent.\\ |
| - | ((n!=0)) | + | S'ils ne sont pas protégés, les opérateurs **<** et **>** sont des opérateurs de redirection.\\ |
| - | echo -e 'Avec n="DuTexte" ; ((n!=0)) renvoie le code retour' $? \\n | + | Démonstration : |
| - | unset n | + | __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> | ||
| + | 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> | </code> | ||
| <file config retour des commandes> | <file config retour des commandes> | ||
| - | ========== | + | bash: let: une expression est attendue |
| + | 1 | ||
| + | bash: let: une expression est attendue | ||
| + | 1 | ||
| + | bash: 423: Aucun fichier ou dossier de ce type | ||
| + | 1 | ||
| + | bash: =424: Aucun fichier ou dossier de ce type | ||
| + | 1 | ||
| + | |||
| + | ls : 420 '=421' | ||
| + | |||
| + | '/tmp/test_let/=421' supprimé | ||
| + | '/tmp/test_let/420' supprimé | ||
| + | répertoire '/tmp/test_let' supprimé | ||
| + | </file> | ||
| + | |||
| + | 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. | ||
| + | |||
| + | Les opérateurs de comparaison sont des opérateurs binaires, ils attendent donc 2 arguments (ou opérandes).\\ | ||
| + | Les commande **<nowiki>((</nowiki>** et **let** retournent une erreur s'il manque un opérande. | ||
| + | <code> | ||
| + | (( == 0)) ; echo $? | ||
| + | let 0>= ; echo $? | ||
| + | echo ===== | ||
| + | (( 42 < "")) ; echo $? | ||
| + | let ""!=24 ; echo $? | ||
| + | </code> | ||
| + | <file config retour des commandes> | ||
| + | bash: ((: == 0 : erreur de syntaxe : opérande attendu (le symbole erroné est « == 0 ») | ||
| + | 1 | ||
| + | bash: let: une expression est attendue | ||
| + | 1 | ||
| + | ===== | ||
| + | bash: ((: 42 < : erreur de syntaxe : opérande attendu (le symbole erroné est « < ») | ||
| + | 1 | ||
| + | bash: let: !=24 : erreur de syntaxe : opérande attendu (le symbole erroné est « !=24 ») | ||
| + | 1 | ||
| + | </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> | ||
| + | echo ===== | ||
| + | (("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 | ||
| + | echo ===== | ||
| + | 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 $?" | ||
| + | </code> | ||
| + | <file config retour des commandes>===== | ||
| bash: ((: Du texte >= 0 : erreur de syntaxe dans l'expression (le symbole erroné est « texte >= 0 ») | bash: ((: Du texte >= 0 : erreur de syntaxe dans l'expression (le symbole erroné est « texte >= 0 ») | ||
| - | (("Du texte" >= 0)) revoie le code de retour 1 | + | (("Du texte" >= 0)) renvoie le code de retour 1 |
| - | (("DuTexte" == 0)) revoie le code de retour 0 | + | 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 ») | bash: ((: Du texte : erreur de syntaxe dans l'expression (le symbole erroné est « texte ») | ||
| - | Avec n="Du texte" ; ((n>=0)) renvoie le code retour 1 | + | Avec n="Du texte" ; ((0<=n)) renvoie le code retour 1 |
| - | Avec n="DuTexte" ; ((n!=0)) 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> | </file> | ||
| + | |||
| + | <note> | ||
| + | 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**. | ||
| + | </note> | ||
| ==== Exemple dans un script ==== | ==== Exemple dans un script ==== | ||
| + | |||
| + | Copions le code ci-dessous dans un fichier nommé mon_script. | ||
| <code bash mon_script> | <code bash mon_script> | ||
| Ligne 130: | Ligne 276: | ||
| a=8 ; b=2 | a=8 ; b=2 | ||
| if (( "$a" < "$b" )) ; then | if (( "$a" < "$b" )) ; then | ||
| - | echo " $a < $b " | + | echo "$a < $b" |
| else | else | ||
| echo "$a n'est pas inférieur à $b" | echo "$a n'est pas inférieur à $b" | ||
| fi | fi | ||
| </code> | </code> | ||
| + | |||
| + | Et exécutons le. | ||
| <code user> | <code user> | ||
| bash mon_script | bash mon_script | ||
| echo $? | echo $? | ||
| + | |||
| + | rm -v mon_script | ||
| </code> | </code> | ||
| <file config retour de la commande> | <file config retour de la commande> | ||
| 8 n'est pas inférieur à 2 | 8 n'est pas inférieur à 2 | ||
| 0 | 0 | ||
| + | 'mon_script' supprimé | ||
| </file> | </file> | ||
| - | 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]]). | + | __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]]). | ||
| - | <note important> | + | ==== Exemple dans une fonction === |
| - | Attention à la confusion avec les tests sur les chaînes de caractères ! | + | |
| - | <code bash script> | + | |
| - | #!/bin/bash | + | |
| - | a=23 | + | |
| - | b=4 | + | |
| - | if (( "$a" < "$b" )) ; then | + | |
| - | echo "$a > $b" | + | |
| - | else | + | |
| - | echo "aïe : $a < $b ???" | + | |
| - | fi | + | |
| - | echo " " | + | |
| - | + | ||
| - | c="23" | + | |
| - | d="24" | + | |
| - | if test "$c" > "$d" ; then | + | |
| - | echo "Attention ! incohérence "$c" > "$d" car avec test et crochets, | + | |
| - | il s'agit de tests sur les chaînes de caractères." | + | |
| - | fi | + | |
| - | 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'' | + | Nous créons ici une fonction (test_si_négatif) qui teste si une expression numérique ou arithmétique est négative. |
| - | >Il s'agit de tests sur les chaînes de caractères, donc il ne s'agit pas de plus petit | + | |
| - | >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]])). | + | |
| - | >De même, attention 26 n'est pas plus grand que 25 ! | + | __Rappel :__ La commande **return** est identique à la commande **exit** (**return** s'utilise dans une fonction, **exit** dans un script). |
| - | >Mais 26 est après 25. | + | |
| - | </note> | + | <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 | ||
| + | } | ||
| + | test_si_négatif ; echo -e $?\\n | ||
| + | test_si_négatif 42 ; echo $? | ||
| + | test_si_négatif -42 ; echo $? | ||
| + | test_si_négatif 42-84 ; echo $? | ||
| + | |||
| + | unset test_si_négatif | ||
| + | </code> | ||
| + | |||
| + | Le troisième usage de notre fonction montre que la commande **<nowiki>((</nowiki>** évalue une expression arithmétique avant de la tester. | ||
| + | |||
| + | <file config retour des commandes> | ||
| + | Argument manquant | ||
| + | 2 | ||
| + | |||
| + | 1 | ||
| + | 0 | ||
| + | 0 | ||
| + | </file> | ||
| ===== Comparaison numérique avec [ et [[ ===== | ===== Comparaison numérique avec [ et [[ ===== | ||
| - | La comparaison numérique peut aussi se réalisée avec les commandes **[** (ou **test**) et **<nowiki>[[</nowiki>**. | + | La comparaison numérique peut aussi se réaliser avec les commandes **[** (ou **test**) et **<nowiki>[[</nowiki>**. |
| Syntaxe : | Syntaxe : | ||
| <code> | <code> | ||
| - | [ expr opérateur expr ] | + | test expr1 OP expr2 |
| - | [[ expr opérateur expr ]] | + | [ expr1 OP expr2 ] |
| + | [[ expr1 OP expr2 ]] | ||
| + | |||
| + | expr1 et expr2 sont sujets au développement des paramètres. | ||
| + | Avec la commande [[, expr1 et expr2 sont sujets à l’évaluation arithmétique. La commande [ (ou test), ne le permet pas. | ||
| + | Avec OP, l'un des opérateurs du tableau suivant. | ||
| </code> | </code> | ||
| - | | Opérateurs de comparaison des commande [ et <nowiki>[[</nowiki> || | + | __Rappel :__ Les commandes **[** et **test** sont équivalentes. |
| - | ^Caractères ^ Significations ^ | + | |
| - | |''-eq '' | est égal à | | + | | Opérateurs de comparaison des commandes [ et <nowiki>[[</nowiki> || |
| - | |''-ne '' | n'est pas égal à | | + | ^Opérateurs ^ Significations ^ |
| - | |''-gt '' | est plus grand que | | + | |''-eq '' | est égal à | |
| - | |''-ge '' |est plus grand ou égal à | | + | |''-ne '' | n'est pas égal à | |
| - | |''-lt '' |est plus petit que | | + | |''-gt '' | est plus grand que | |
| - | |''-le '' |est plus petit ou égal à | | + | |''-ge '' |est plus grand ou égal à | |
| + | |''-lt '' |est plus petit que | | ||
| + | |''-le '' |est plus petit ou égal à | | ||
| + | |||
| + | ==== Exemples dans le terminal ==== | ||
| - | |||
| - | ===Exemples dans le terminal === | ||
| <code user> | <code user> | ||
| - | [ 25 -eq 20 ] | + | [ 25 -eq 20 ] # Teste si 25 est égale à 20 |
| echo $? | echo $? | ||
| </code> | </code> | ||
| Ligne 213: | Ligne 380: | ||
| 1 | 1 | ||
| </file> | </file> | ||
| - | |||
| - | == Ou encore : == | ||
| <code user> | <code user> | ||
| var1=17 | var1=17 | ||
| var2=18 | var2=18 | ||
| - | [ "$var1" -gt "$var2" ] | + | echo "$var1 est-il plus grand que $var2 : $([ $var1 -gt $var2 ]; echo $?)" |
| - | 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 var1 var2 | ||
| </code> | </code> | ||
| - | == OU mieux : == | + | <file config retour de la commande> |
| + | 17 est-il plus grand que 18 : 1 | ||
| + | 17 est-il plus petit que 18 : 0 | ||
| + | 17 est-il différent de 18 : 0 | ||
| + | </file> | ||
| + | |||
| + | ==== Particularités de la commande [[ ==== | ||
| + | |||
| + | Seule la commande **<nowiki>[[</nowiki>** permet de tester une expression arithmétique. | ||
| <code user> | <code user> | ||
| - | test 100 -gt 99 && echo "vrai" || echo "faux" # retour : vrai | + | test 21+21 -eq 42 ; echo -e $?\\n |
| + | |||
| + | [ 21*2 -eq 42 ] ; echo -e $?\\n | ||
| + | |||
| + | [[ 84-42 -eq 42 ]] ; echo $? | ||
| </code> | </code> | ||
| + | <file config retour des commandes> | ||
| + | bash: test: 21+21 : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | |||
| + | bash: [: 21*2 : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | |||
| + | 0 | ||
| + | </file> | ||
| + | |||
| + | __Rappel :__ Lorsque le code de retour d'une commande interne renvoie **2**, cela signifie un mauvais usage de cette commande. | ||
| + | |||
| + | Elle est aussi la seule à accepter les chaînes vides qui sont alors évaluées à **0**. | ||
| + | |||
| <code user> | <code user> | ||
| - | test 100 -lt 99 && echo "vrai" || echo "faux" # retour : faux | + | [[ 0 -eq "" ]] ; echo $? |
| + | [[ "" -ne 0 ]] ; echo $? | ||
| + | [[ "" -eq "" ]] ; echo $? | ||
| </code> | </code> | ||
| + | <file config retour des commande> | ||
| + | 0 | ||
| + | 1 | ||
| + | 0 | ||
| + | </file> | ||
| + | |||
| + | Idem pour les chaînes de caractères sans espace (mots). Un mot est substitué par **0**. | ||
| <code user> | <code user> | ||
| - | [ 5 -eq 5 ]; echo $? | + | [[ mot -eq 0 ]] ; echo $? |
| + | [[ 0 -ne mot ]] ; echo $? | ||
| + | [[ mot1 -eq mot2 ]] ; echo $? | ||
| </code> | </code> | ||
| + | <file config retour des commandes> | ||
| + | 0 | ||
| + | 1 | ||
| + | 0 | ||
| + | </file> | ||
| - | <file config retour de la commande> | + | ==== Mauvais usages ==== |
| - | 0 | + | |
| + | Le caractère **$** est obligatoire pour développer les arguments. Sans, ils sont interprétés comme des mots. | ||
| + | |||
| + | Avec la commande **[** (ou **test**), les chaînes vides ou les mots sont à proscrire. | ||
| + | |||
| + | <code user> | ||
| + | test 42 -eq "" ; echo $? | ||
| + | [ 42 -lt "" ] ; echo $? | ||
| + | echo ===== | ||
| + | test "" -gt 42 ; echo $? | ||
| + | [ "" -ge 42 ] ; echo $? | ||
| + | </code> | ||
| + | <file config retour des commande> | ||
| + | bash: test: : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | bash: [: : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | ===== | ||
| + | bash: test: : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | bash: [: : nombre entier attendu comme expression | ||
| + | 2 | ||
| </file> | </file> | ||
| - | >car l'expression est vraie | ||
| - | === Exemple avec la commande test dans le terminal:=== | ||
| <code user> | <code user> | ||
| - | test 17 -gt 11 ; echo $? | + | test mot -eq 0 ; echo $? |
| + | [ 0 -eq mot ] ; echo $? | ||
| + | test O -le 0 ; echo $? | ||
| + | [ "mot" -ge 0 ] ; echo $? | ||
| + | echo $? | ||
| </code> | </code> | ||
| + | <file config retour des commandes> | ||
| + | bash: test: mot : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | bash: [: mot : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | bash: test: O : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | bash: [: mot : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | </file> | ||
| - | <file config retour de la commande> | + | Avec **[** (ou **test**) et **<nowiki>[[</nowiki>**, les opérandes ne peuvent être des chaînes de caractères qui comportent des espaces. |
| - | 0 | + | |
| + | <code user> | ||
| + | test "Du texte" -eq 0 ; echo $? | ||
| + | [ 0 -ge "Du texte" ] ; echo $? | ||
| + | [[ "Du texte" -ge 0 ]] ; echo $? | ||
| + | </code> | ||
| + | <file config retour des commandes> | ||
| + | bash: test: Du texte : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | bash: [: Du texte : nombre entier attendu comme expression | ||
| + | 2 | ||
| + | bash: [[: Du texte : erreur de syntaxe dans l'expression (le symbole erroné est « texte ») | ||
| + | 1 | ||
| </file> | </file> | ||
| - | De même : | + | <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> | ||
| + | |||
| + | Les deux opérandes sont obligatoires. | ||
| <code user> | <code user> | ||
| - | var1=17 ; var2=11 ; test "$var1" -gt "$var2" ; echo $? | + | test 42 -eq ; echo $? |
| + | [ 42 -lt ] ; echo $? | ||
| + | [[ 42 -ne ]] | ||
| + | echo $? | ||
| + | echo ===== | ||
| + | test -gt 42 ; echo $? | ||
| + | [ -ge 42 ] ; echo $? | ||
| + | [[ -le 42 ]] | ||
| + | echo $? | ||
| </code> | </code> | ||
| + | <file config retour des commandes> | ||
| + | bash: test: 42 : opérateur unaire attendu | ||
| + | 2 | ||
| + | bash: [: 42 : opérateur unaire attendu | ||
| + | 2 | ||
| + | bash: argument « ]] » inattendu pour l'opérateur binaire conditionnel | ||
| + | bash: erreur de syntaxe près de « ]] » | ||
| + | 2 | ||
| + | ===== | ||
| + | bash: test: -gt : opérateur unaire attendu | ||
| + | 2 | ||
| + | bash: [: -ge : opérateur unaire attendu | ||
| + | 2 | ||
| + | bash: opérateur binaire conditionnel attendu | ||
| + | bash: erreur de syntaxe près de « 42 » | ||
| + | 2 | ||
| + | </file> | ||
| - | <file config retour de la commande> | + | Ainsi que les espaces. |
| - | 0 | + | |
| + | <code user> | ||
| + | [24 -ne 24 ] ; echo $? | ||
| + | [[24 -le 24 ]] | ||
| + | echo $? | ||
| + | echo ==== | ||
| + | [ 24 -ne 24] ; echo $? | ||
| + | [[ 24 -le 24]] | ||
| + | echo $? | ||
| + | echo ==== | ||
| + | test 42-gt 0 ; echo $? | ||
| + | [ 42 -eq0 ] ; echo $? | ||
| + | [[ 42 -ne0 ]] | ||
| + | echo $? | ||
| + | </code> | ||
| + | <file config retour des commandes> | ||
| + | bash: [24 : commande introuvable | ||
| + | 127 | ||
| + | bash: [[24 : commande introuvable | ||
| + | 127 | ||
| + | ==== | ||
| + | bash: [: « ] » manquant | ||
| + | 2 | ||
| + | bash: erreur de syntaxe dans une expression conditionnelle | ||
| + | bash: erreur de syntaxe près de « echo » | ||
| + | ==== | ||
| + | bash: test: 42-gt : opérateur unaire attendu | ||
| + | 2 | ||
| + | bash: [: 42 : opérateur unaire attendu | ||
| + | 2 | ||
| + | bash: opérateur binaire conditionnel attendu | ||
| + | bash: erreur de syntaxe près de « -ne0 » | ||
| + | 2 | ||
| </file> | </file> | ||
| - | ===Exemple avec les crochets dans un script:=== | + | |
| - | <code bash mon-script> | + | __Rappel :__ Le code retour 127, signifie que la commande n'a pas été trouvée. |
| - | #!/bin/bash | + | |
| - | a=2 ; b=1 | + | 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\\ |
| - | if [ "$a" -gt "$b" ] ; then | + | Puisque la chaîne est non vide, le test n'échoue pas. |
| - | echo "$a est plus grand que $b" | + | <code user> |
| - | fi | + | test 420-ne420 ; echo $? |
| + | [ 420-gt42 ] ; echo $? | ||
| + | [[ 42-lt420 ]] ; echo $? | ||
| </code> | </code> | ||
| + | <file config retour des commandes> | ||
| + | 0 | ||
| + | 0 | ||
| + | 0 | ||
| + | </file> | ||
| + | |||
| + | 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 lexicographiques]]). | ||
| + | __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> | <code user> | ||
| - | ./mon-script : | + | test 425 \> 4242 ; echo $? |
| + | [ 426 \> 4242 ] ; echo $? | ||
| + | [[ 4242 < 427 ]] ; echo $? | ||
| </code> | </code> | ||
| - | <file config retour de la commande> | + | <file config retour des commandes> |
| - | 2 est plus grand que 1 | + | 0 |
| + | 0 | ||
| + | 0 | ||
| </file> | </file> | ||
| - | ===Exemple avec la commande test dans un script:=== | + | 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. |
| + | |||
| + | ==== Exemples dans un script ==== | ||
| + | |||
| + | Copions le code ci-dessous dans le fichier mon_script. | ||
| + | |||
| + | <code bash mon_script> | ||
| + | #!/bin/bash | ||
| + | a=2 ; b=1 | ||
| + | if [ "$a" -gt "$b" ] ; then | ||
| + | echo "$a est plus grand que $b" | ||
| + | fi | ||
| - | <code bash mon-script> | ||
| if test 100 -gt 99 | if test 100 -gt 99 | ||
| then | then | ||
| Ligne 279: | Ligne 624: | ||
| else | else | ||
| echo "faux" | echo "faux" | ||
| - | fi | + | fi |
| </code> | </code> | ||
| <code user> | <code user> | ||
| - | ./mon-script | + | bash mon_script |
| + | |||
| + | rm -f mon_script | ||
| </code> | </code> | ||
| <file config retour de la commande> | <file config retour de la commande> | ||
| + | 2 est plus grand que 1 | ||
| vrai | vrai | ||
| + | 'mon_script' supprimé | ||
| </file> | </file> | ||
| <note important> | <note important> | ||
| Attention : | Attention : | ||
| - | <code bash mon-script> | + | <code bash mon_script> |
| #!/bin/bash | #!/bin/bash | ||
| var1=8 | var1=8 | ||
| Ligne 298: | Ligne 647: | ||
| echo " $var1 est plus grand que $var2 " | echo " $var1 est plus grand que $var2 " | ||
| fi | fi | ||
| - | echo " " | + | printf \\n |
| - | if test 8 -gt 7 ; then | + | test 8 -gt 7 && echo "$var1 est plus grand que $var2" |
| - | echo " $var1 est plus grand que $var2 " | + | |
| - | fi | + | |
| </code> | </code> | ||
| <code user> | <code user> | ||
| - | ./mon-script | + | bash mon_script |
| + | |||
| + | rm -v mon_script | ||
| </code> | </code> | ||
| <file config retour de la commande> | <file config retour de la commande> | ||
| - | : ligne 18 : test: : nombre entier attendu comme expression | + | mon_script: ligne 4 : test: : nombre entier attendu comme expression |
| - | + | ||
| - | 8 est plus grand que 7 | + | 8 est plus grand que 7 |
| + | 'mon_script' supprimé | ||
| </file> | </file> | ||
| </note> | </note> | ||
