logo Debian Debian Debian-France Debian-Facile Debian-fr.org Forum-Debian.fr Debian ? Communautés logo inclusivité

Debian-facile

Bienvenue sur Debian-Facile, site d'aide pour les nouveaux utilisateurs de Debian.

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 → ODT PDF Export

Ceci est une ancienne révision du document !


Bash : les opérateurs de comparaison numérique

Nota : Contributeurs, les FIXME sont là pour vous aider, supprimez-les une fois le problème corrigé ou le champ rempli !

Introduction

En interne, bash dispose de plusieurs commandes pour réaliser des comparaisons numériques:

  • La commande composée (( et la commande let.
  • Les commandes [ et test.
  • Et la commande composée [[.

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 && exécute la commande suivante, si la commande précédente à renvoyée le code retour true (égale à 0).
  • L'opérateur || 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 ((

Syntaxe :

(( 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.
Opérateurs de comparaison numérique de la commande ((
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

Exemples dans le terminal

(( 42 == 42 ))			# Est-ce que 42 est égale à 42.
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.
 
unset nombre1 nombre2		# Suppression des paramètres nombre1 et nombre2
retour de la commande
0
1

Les paramètres peuvent être transmis sans $ (Sauf les paramètres positionnels et les paramètres spéciaux)
Les espaces peuvent être omis.

n1=42
n2=24
(( n1 > n2 )) && echo "$n1 > $n2" || echo "$n1 < $n2"
 
if ((n1>n2))
then
	echo "$n1 est supérieur à $n2"
else
	echo "$n1 est inférieur à $n2"
fi
 
unset n1 n2
retour de la commande
42 > 24
42 est supérieur à 24

Le développement des opérandes doivent être des valeurs numériques.
Mais comme nous l'avons vu au dessus, les paramètre n'ont pas besoin du 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).

echo ==========
(("Du texte" >= 0))
echo -e "((\"Du texte\" >= 0)) revoie le code de retour $? \n"
 
(("DuTexte" == 0))
echo -e "((\"DuTexte\" == 0)) revoie le code de retour $? \n"
 
n="Du texte"
((n>=0))
echo -e 'Avec n="Du texte" ; ((n>=0)) renvoie le code retour' $? \\n
 
n="Dutexte"
((n!=0))
echo -e 'Avec n="DuTexte" ; ((n!=0)) renvoie le code retour' $? \\n
 
unset n
retour des commandes
==========
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 
 
(("DuTexte" == 0)) revoie le code de retour 0 
 
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="DuTexte" ; ((n!=0)) renvoie le code retour 1 

Exemple dans un script

Copions le code ci-dessous dans un fichier nommé mon_script.

mon_script
#!/bin/bash
a=8 ; b=2
if (( "$a" < "$b" )) ; then
  echo "$a < $b"
else
  echo "$a n'est pas inférieur à $b"
fi

Et exécutons le.

bash mon_script
echo $?
 
rm -v mon_script
retour de la commande
8 n'est pas inférieur à 2
0
'mon_script' supprimé

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 utilisation de la commande exit).

Exemple dans une fonction

Nous créons ici une fonction (test_si_négatif) qui teste si une expression numérique ou arithmétique est négative.

Rappel : La commande return est identique à la commande exit (return s'utilise dans une fonction, exit dans un script).

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

Le troisième usage de notre fonction montre que la commande (( évalue une expression arithmétique avant de la tester.

retour des commandes
Argument manquant
2
 
1
0
0

Comparaison numérique avec [ et [[

La comparaison numérique peut aussi se réaliser avec les commandes [ (ou test) et [[.

Syntaxe :

test expr1 OP expr2
[ 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.

Rappel : Les commandes [ et test sont équivalentes.

Opérateurs de comparaison des commandes [ et [[
Opérateurs Significations
-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 dans le terminal

[ 25 -eq 20 ]	# Teste si 25 est égale à 20
echo $?
retour de la commande
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
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

Particularités de la commande [[

Seule la commande [[ permet de tester une expression arithmétique.

test 21+21 -eq 42 ; echo -e $?\\n
 
[ 21*2 -eq 42 ] ; echo -e $?\\n
 
[[ 84-42 -eq 42 ]] ; echo $?
retour des commandes
bash: test: 21+21 : nombre entier attendu comme expression
2
 
bash: [: 21*2 : nombre entier attendu comme expression
2
 
0

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.

[[ 0 -eq "" ]] ; echo $?
[[ "" -ne 0 ]] ; echo $?
[[ "" -eq "" ]] ; echo $?
retour des commande
0
1
0

Idem 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 $?
retour des commandes
0
1
0

Mauvais usages

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.

test 42 -eq "" ; echo $?
[ 42 -lt "" ] ; echo $?
echo =====
test "" -gt 42 ; echo $?
[ "" -ge 42 ] ; echo $?
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
test mot -eq 0	; echo $?
[ 0 -eq mot ]	; echo $?
test O -le 0	; echo $?
[ "mot" -ge 0 ]	; echo $?
echo $?
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

Avec [ (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 $?
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
Il est remarquable que le test [[ "Du texte" -ge 0 ]], ne renvoie pas le code de retour 2.
Pourtant il s'agit bien d'un mauvais usage de la commande [[.

Les deux opérandes sont obligatoires.

test 42 -eq ; echo $?
[ 42 -lt ] ; echo $?
[[ 42 -ne ]]
echo $?
echo =====
test -gt 42 ; echo $?
[ -ge 42 ] ; echo $?
[[ -le 42 ]]
echo $?
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

Ainsi que les espaces.

[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 $?
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

Rappel : Le code retour 127, signifie que la commande n'a pas été trouvée.

Lorsqu'il n'y pas d'espaces entre les opérandes et l'opérateur, l'ensemble est considérer comme une chaîne de caractères
Puisque la chaîne est non vide, le test n'échoue pas.

test 420-ne420	; echo $?
[ 420-gt42 ]	; echo $?
[[ 42-lt420 ]]	; echo $?
retour des commandes
0
0
0

Ne pas utiliser les opérateurs < et > avec [ (ou test) et [[ pour réaliser des comparaisons numériques.
Car avec ces commandes, ces opérateur sont des opérateurs de comparaison lexicographique.
(voir Bash : les opérateurs lexicographiques).

Rappel : Avec [ (ou test), les opérateurs < et > s'utilisent protégés (voir Bash, comparaison lexicographique avec [ ou test).

test 425 \> 4242 ; echo $?
[ 426 \> 4242 ]		; echo $?
[[ 4242 < 427 ]]	; echo $?
retour des commandes
0
0
0

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.

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
retour de la commande
2 est plus grand que 1
vrai
'mon_script' supprimé
Attention :
mon_script
#!/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
retour de la commande
mon_script: ligne 4 : test:  : nombre entier attendu comme expression
 
8 est plus grand que 7 
'mon_script' supprimé

Conclusion sur les opérateurs lexicographiques et les opérateurs de comparaison numérique

Yep, plus de confusions !

Nous avons vu :
  • qu'il y a deux mécanismes pour effectuer des tests, la paire de crochets et la commande test;
  • qu'à chaque mécanisme sa syntaxe :
$ test -f /etc/gaga

Ou

$ [ -f /etc/gaga ]

(Si le fichier /etc/gaga existait, le code de retour serait 0.
Voir la commande exit et son utilisation dans les scripts.)

  • que, pour des comparaisons sur les nombres on utilise :

soit les doubles parenthèses avec les opérateurs booléens :

 ==    !=   <	>   >=   <=

soit les crochets (ou la commande “test”) avec les opérateurs :

-eq   -ne   -gt   -ge   -lt   -le
  • 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 ;
  • 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

Plein d'exemples dans ce wiki en anglais : http://wiki.bash-hackers.org/commands/classictest

:-D

Pour aller plus loin : les opérateurs logiques.

Ils s'utilisent avec les tests.

Opérateur Signification
! Négation
-a et
-o ou

Et dans un ordre précis :

  1. ! (négation)
  2. -a (et)
  3. -o (ou)
  • Il doit toujours y avoir un espace autour des opérateurs: !, -a, -o.
  • Ne pas confondre -a (opérateur logique) avec un opérateur de test sur les fichiers.
  • Ne pas confondre -o (opérateur logique) avec -ot (test pour savoir si un fichier1 est plus ancien qu'un fichier2.
  • Il est possible de modifier la priorité d'exécution des opérateurs en utilisant des parenthèses.
  • Les parenthèses doivent être protégées par des anti-slash afin de ne pas être interprétées par le shell comme étant un regroupement de commandes: \\\(…\)

Exemples :

  • Le fichier “toto” n'est pas un répertoire :
[ ! -d /etc/group ]
echo $?
retour de la commande
 0
Il est vrai (retour 0) que ce “n'est pas” ;-)
  • Le fichier mon-script existe et est exécutable :
[ -f mon-script -a -x mon-script ]
echo $?
retour de la commande
 0

Tuto précédent

La suite c'est ici :

1)
N'hésitez pas à y faire part de vos remarques, succès, améliorations ou échecs !
doc/programmation/shells/page-man-bash-iii-les-operateurs-de-comparaison-numerique.1676470419.txt.gz · Dernière modification: 15/02/2023 15:13 par agp91

Pied de page des forums

Propulsé par FluxBB