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 →
Ceci est une ancienne révision du document !
Nota : Contributeurs, les sont là pour vous aider, supprimez-les une fois le problème corrigé ou le champ rempli !
Bash dispose de plusieurs commandes pour réaliser des comparaisons numérique.
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 à |
[ 25 -eq 20 ] # Teste si 25 est égale à 20 echo $?
1
var1=17 var2=18 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 var1 var2
17 est-il plus grand que 18 : 1 17 est-il plus petit que 18 : 0 17 est-il différent de 18 : 0Copions le code ci-dessous dans le fichier mon_script.
#!/bin/bash a=2 ; b=1 if [ "$a" -gt "$b" ] ; then echo "$a est plus grand que $b" fi if test 100 -gt 99 then echo "vrai" #réponse : vrai else echo "faux" fi
bash mon_script rm -f mon_script
2 est plus grand que 1 vrai 'mon_script' supprimé==== Particularités de la commande echo -e $ ; echo $? </code>
bash: test: 21+21 : nombre entier attendu comme expression 2 bash: [: 21*2 : nombre entier attendu comme expression 2 0
[[ 0 -eq "" ]] ; echo $? [[ "" -ne 0 ]] ; echo $? [[ "" -eq "" ]] ; echo $?
0 1 0Idem pour les chaînes de caractères sans espace (mots). Un mot est substitué par 0.
[[ mot -eq 0 ]] ; echo $? [[ 0 -ne mot ]] ; echo $? [[ mot1 -eq mot2 ]] ; echo $?
0 1 0
#!/bin/bash var1=8 var2=7 if test "$e" -gt "$f" ; then echo " $var1 est plus grand que $var2 " fi printf \\n test 8 -gt 7 && echo "$var1 est plus grand que $var2"
bash mon_script rm -v mon_script
mon_script: ligne 4 : test: : nombre entier attendu comme expression 8 est plus grand que 7 'mon_script' supprimé
test 42 -eq "" ; echo $? [ 42 -lt "" ] ; echo $? echo ===== test "" -gt 42 ; echo $? [ "" -ge 42 ] ; echo $?
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
test mot -eq 0 ; echo $? [ 0 -eq mot ] ; echo $? test O -le 0 ; echo $? [ "mot" -ge 0 ] ; echo $? echo $?
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 2Avec [ (ou test) et [[, les opérandes ne peuvent être des chaînes de caractères qui comportent des espaces.
test "Du texte" -eq 0 ; echo $? [ 0 -ge "Du texte" ] ; echo $? [[ "Du texte" -ge 0 ]] ; echo $?
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
[[ "Du texte" -ge 0 ]]
, ne renvoie pas le code de retour 2.[[
.
test 42 -eq ; echo $? [ 42 -lt ] ; echo $? [[ 42 -ne ]] echo $? echo ===== test -gt 42 ; echo $? [ -ge 42 ] ; echo $? [[ -le 42 ]] echo $?
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 » 2Ainsi que les espaces.
test 420-ne420 ; echo $? [ 420-gt42 ] ; echo $? [[ 42-lt420 ]] ; echo $?
0 0 0Ne pas utiliser les opérateurs < et > avec [ (ou test) et [[ pour réaliser des comparaisons numériques.
test 425 \> 4242 ; echo $? [ 426 \> 4242 ] ; echo $? [[ 4242 < 427 ]] ; echo $?
0 0 0
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.Remarques : Les commandes let et (( sont équivalentes.
Opérateurs de comparaison numérique des commandes let et (( | |
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 |
<= | Comparaison de plus petit ou égal que |
(( 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.
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 nombre2Les paramètres peuvent être transmis sans $ (Sauf les paramètres positionnels et les paramètres spéciaux).
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
42 > 24 42 est différent de 24
(("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
(("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
n= ((n==0)) ; echo $? let 'n != 0' ; echo $? unset nAvec la commande ((, les espaces ne sont pas obligatoires.
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
4242 est supérieur à 2424
let -42 \< 0 ; echo $? let 0 == 0 ; echo $?
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
n=42 let 'n==42' ; echo $? let '$n > 42' ; echo $?
0 bash: let: $n == 42 : erreur de syntaxe : opérande attendu (le symbole erroné est « $n == 42 ») 1
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
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é
(( == 0)) ; echo $? let 0>= ; echo $? echo ===== (( 42 < "")) ; echo $? let ""!=24 ; echo $?
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
(("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
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
#!/bin/bash a=8 ; b=2 if (( "$a" < "$b" )) ; then echo "$a < $b" else echo "$a n'est pas inférieur à $b" fi
bash mon_script echo $? rm -v mon_script
8 n'est pas inférieur à 2 0 'mon_script' supprimé
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égatifLe troisième usage de notre fonction montre que la commande (( évalue une expression arithmétique avant de la tester.
Argument manquant 2 1 0 0
17 est-il plus grand que 18 : 1 17 est-il plus petit que 18 : 0 17 est-il différent de 18 : 0
bash: test: 21+21 : nombre entier attendu comme expression 2 bash: [: 21*2 : nombre entier attendu comme expression 2 0
[[ 0 -eq "" ]] ; echo $? [[ "" -ne 0 ]] ; echo $? [[ "" -eq "" ]] ; echo $?
0 1 0
[[ mot -eq 0 ]] ; echo $? [[ 0 -ne mot ]] ; echo $? [[ mot1 -eq mot2 ]] ; echo $?
0 1 0
test 42 -eq "" ; echo $? [ 42 -lt "" ] ; echo $? echo ===== test "" -gt 42 ; echo $? [ "" -ge 42 ] ; echo $?
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
test mot -eq 0 ; echo $? [ 0 -eq mot ] ; echo $? test O -le 0 ; echo $? [ "mot" -ge 0 ] ; echo $? echo $?
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
test "Du texte" -eq 0 ; echo $? [ 0 -ge "Du texte" ] ; echo $? [[ "Du texte" -ge 0 ]] ; echo $?
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
[[ "Du texte" -ge 0 ]]
, ne renvoie pas le code de retour 2.[[
.
test 42 -eq ; echo $? [ 42 -lt ] ; echo $? [[ 42 -ne ]] echo $? echo ===== test -gt 42 ; echo $? [ -ge 42 ] ; echo $? [[ -le 42 ]] echo $?
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
[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 $?
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
test 420-ne420 ; echo $? [ 420-gt42 ] ; echo $? [[ 42-lt420 ]] ; echo $?
0 0 0
test 425 \> 4242 ; echo $? [ 426 \> 4242 ] ; echo $? [[ 4242 < 427 ]] ; echo $?
0 0 0
#!/bin/bash a=2 ; b=1 if [ "$a" -gt "$b" ] ; then echo "$a est plus grand que $b" fi if test 100 -gt 99 then echo "vrai" #réponse : vrai else echo "faux" fi
bash mon_script rm -f mon_script
2 est plus grand que 1 vrai 'mon_script' supprimé
#!/bin/bash var1=8 var2=7 if test "$e" -gt "$f" ; then echo " $var1 est plus grand que $var2 " fi printf \\n test 8 -gt 7 && echo "$var1 est plus grand que $var2"
bash mon_script rm -v mon_script
mon_script: ligne 4 : test: : nombre entier attendu comme expression 8 est plus grand que 7 'mon_script' supprimé
$ test -f /etc/gagaOu
$ [ -f /etc/gaga ](Si le fichier /etc/gaga existait, le code de retour serait 0.
== != < > >= <=soit les crochets (ou la commande “test”) avec les opérateurs :
-eq -ne -gt -ge -lt -le
-eq
; -ne
; -gt
; -ge
; -lt
; -le
sur les nombres mais pas sur les chaînes de caractères ;-e
; -d
; -f
; -L
; -r
; -w
; -x
; $fichier1 -nt
$fichier2 ; $fichier1 -ot
$fichier2Opérateur | Signification |
---|---|
! | Négation |
-a | et |
-o | ou |
!
, -a
, -o
.-a
(opérateur logique) avec un opérateur de test sur les fichiers.-o
(opérateur logique) avec -ot
(test pour savoir si un fichier1 est plus ancien qu'un fichier2.\(…\)
[ ! -d /etc/group ]
echo $?
Il est vrai (retour 0) que ce “n'est pas”
[ -f mon-script -a -x mon-script ]
echo $?=====Tuto précédent===== Bash : les opérateurs lexicographiques =====La suite c'est ici : ===== Bash : les symboles dans les calculs