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 lexicographiques

Introduction

En interne, bash dispose de plusieurs commandes pour réaliser des tests sur des paramètres, des chaînes de caractères, des fichiers ou encore faire des comparaison numériques :

  • 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.
Elles ont toutes les deux la même page de manuel (man [ ou man test).
Les commandes internes disposent des opérateurs que n'ont pas les commandes externes.

Rappels :

  • 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.
  • 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 un code de retour égale à 0.
  • L'opérateur || exécute la commande suivante, si la commande précédente à renvoyée un code de retour supérieur à 0.

Opérateurs sur les paramètres

Les commandes de test disposent de deux opérateurs unaires pour tester les paramètres.

test OP nom_paramètre
[ OP nom_paramètre ]
[[ OP nom_paramètre ]]

Chaîne est sujette au développement des paramètres.
Avec pour OP, l'un des opérateur du tableau suivant.
Opérateurs sur paramètre
Opérateurs Retours
-v Vrai si le paramètre existe
-R Vrai si le paramètre est une référence de nom

Exemples

Testons si le paramètre var existe.

var="Debian Facile"		# var existe et n'est pas une chaîne vide
[ -v var ]	; echo $?
 
var=				# var existe et est une chaîne vide
test -v var	; echo $?
 
unset var			# Destruction de var (var n’existe plus).
[[ -v var ]]	; echo $?
0
0
1

Rappel : Une référence de nom est un paramètre qui mémorise le nom d'un autre paramètre.
Il est nécessaire d'utilisé la commande declare -n pour construire une référence de nom.

var="Debian GNU Linux"
declare -n v=var

echo var=$var
echo v=$v
v="Debian Facile"
echo var=$var

[ -R var ] ; echo $?
[[ -R v ]] ; echo $?

declare -p var v

unset var v
Retour des commandes
var=Debian GNU Linux
v=Debian GNU Linux
var=Debian Facile
1
0
declare -- var="Debian Facile"
declare -n v="var"

Les opérateurs de test sur chaînes

Introduction

Dans la page du manuel de bash, les opérateurs des commandes de test sont nommées primitives.

Bash dispose de plusieurs commandes pour réaliser des tests sur des paramètres.

  • Les commandes internes [ et test.
  • Et la commande composée [[.
  • 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.
Rappels :
  • 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.
  • Le code retour d'une commande est mémorisé dans le paramètre spécial $?.
  • 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.
  • 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.

Les commandes de test disposes de 7 primitives (2 unaires et 5 binaires) pour tester des chaînes.

Tester une chaîne (vide ou pas)

Les commandes de test disposent de deux opérateurs unaires pour tester si une chaîne est vide (de longueur nulle) ou pas.

Synopsis

  • test OP chaîne
  • [ OP chaîne ]
  • [[ OP chaîne ]]
  • Avec :
    • Chaîne est sujette au développement des paramètres.
    • OP, l'un des opérateur du tableau suivant.
Liste des primitives de test sur une chaîne
Primitives Retours
-z Vrai si chaîne de longueur nulle.
-n Vrai si chaîne de longueur non nulle.
La primitive -n peut-être omis.

Exemples

Testons une chaîne vide.

test -z		; echo $?	#Test si vide et affiche le code retour
[ -n "" ]	; echo $?	#Test si non vide et affiche le code retour
[[ "" ]]	; echo $?	#Test si non vide et affiche le code retour
0
1
1

Testons une chaînes non vide.

test -z "mot"		; echo $?
[[ -n "Linux" ]]	; echo $?
[[ "GNU Linux" ]]	; echo $?
1
0
0

Testons la variable v si elle est, de longueur non nulle, nulle ou si elle n'existe pas.

v="Debian GNU Linux"
test -z "$v"	; echo $?
 
v=""
[ -n "$v" ]	; echo $?
 
unset v			# Supprime le paramètre v (il n'existe plus).
[[ -z "$v" ]]	; echo $?
[ "$v" ]	; echo $?
1
0
0
1

Mauvais usages

Les opérateurs -z et -n sont des opérateurs unaires, il n'accepte qu'un seul opérande (argument).
Si sa valeur contient des espaces, il doit être protégé par des guillemets doubles.

p="Debian Facile"
test -z $p ; echo $?
 
unset p
bash: test: Debian : opérateur binaire attendu
2
  • Lorsqu'une commande interne renvoie un code de retour 2, cela signifie un mauvais usage de cette commande.

L'opérateur -n renvoie un code de retour inattendu, quand un paramètre vide est testé sans protection.
Sauf avec la commande [[.

test -n $p	; echo $?
[ -n $p ]	; echo $?
 
p=""
[[ -n $p ]]	; echo $?
 
unset p
0
0
1

Astuces

Avec la primitive -z, nous pouvons nous affranchir de la protection des guillemets en utilisant le remplacement des paramètre et l'opérateur +.
(Voir Substitution de la valeur d'un paramètre)

p="Debian GNU Linux"
 
test -z ${p+x}	; echo $?
 
unset p
[[ -z ${p+x} ]]	; echo $?
1
0

Lors du remplacement d'un paramètre, l’opérateur + permet, si la valeur du paramètre est non nulle, de la substituée par une autre valeur (ici x).

Avec la primitive -n les guillemets restent nécessaires au cas ou le paramètre mémorise une chaîne vide, sauf avec la commande [[.

p="Debian Facile"
 
[[ -n ${p+x} ]]	; echo $?
[[ -${p+x} ]]	; echo $?
 
unset p
[[ -n ${p+x} ]]	; echo $?
[[ -${p+x} ]]	; echo $?
0
0
1
1

Comparaison entre deux chaînes

Les commandes de test disposent de 5 primitives binaires pour comparer deux chaînes entre elles.

Syntaxe

  • test chaîne1 OP chaîne2
  • [ chaîne1 OP chaîne2 ]
  • [[ chaîne1 OP chaîne2 ]]
  • Avec :
    • Chaîne1 et chaîne2 sont sujettes au développement des paramètres.
    • OP, l'un des opérateur du tableau suivant.
Si un opérande (chaîne1 ou chaîne2) est une chaîne vide, ou contient des espaces,
Il doit être protégé, placé entre guillemets simples ou doubles.
Listes des primitives de comparaison entre deux chaînes
Primitives Retours
= Vrai si Chaîne1 correspond à Chaîne2 .
== Synonyme de =
!= Vrai si Chaîne1 ne correspond pas à Chaîne2.
< Vrai si chaine1 est placée lexicographiquement avant chaine2
> Vrai si chaine1 est placée lexicographiquement après chaine2

Exemples

-bashismes :
[[ $a == "z*" ]]  # vrai si $a est égal à z*
[[ $a == z* ]]    # vrai si $a commence avec un "z" (reconnaissance de modèles)
[[ "$a" < "$b" ]] # vrai si $a se trouve avant $b dans le dictionnaire

-posix :

[ "$a" = "z*" ]  # vrai si $a est égal à z*
[ "$a" \< "$b" ] # vrai si $a se trouve avant $b dans le dictionnaire
test "GNU" == "GNU" ]		; echo $?
[[ "GNU" != "GNU Linux" ]]	; echo $?
0
0
Donc la chaîne “GNU” est identique à elle-même ;), mais pas à “GNU Linux”.
v1="Debian GNU Linux"
v2="Debian Facile"
if [ "$v1" = "$v2" ]	
then
	echo 'vrai'
else
	echo 'faux'
fi
 
unset v1 v2
faux
Donc les deux chaînes contenues dans les variables v1 et v2 ne sont pas égales.

Copions le code suivant dans le fichier mon_script.

mon_script
#!/bin/bash
var1="def"
var2="def"
if [ "$var1" == "$var2" ] ; then
   echo "1) \$var1 ($var1) correspond(==) à \$var2 ($var2)."
fi
 
var3="hip"
var4="hip"
if test "$var3" = "$var4"  ; then
   echo "2) \$var3 ($var3) correspond(=) à \$var4 ($var4)."
fi
bash mon_script
 
rm -v mon_script
1) $var1 (def) correspond(==) à $var2 (def).
2) $var3 (hip) correspond(=) à $var4 (hip).
'mon_script' supprimé

Les commandes de test permettent de réaliser des test de comparaison lexicographique.
(voir https://debian-facile.org/atelier:chantier:bash-comparaison-lexicographique-des-chaines.)

Attention de ne pas confondre les primitives de comparaison lexicographique sur les chaînes avec les opérateurs de comparaison numérique qui utilisent les mêmes caractères.
a="sloiuy"
b="aktgjaùkjayaj"
 
if [[ $a < $b ]] ; then 
   echo "OK l'opérateur < fonctionne avec les chaînes de caractère"
fi
 
if [[ $a > $b ]] ; then 
   echo "Les opérateurs < et > signifient avant et après selon l'ordre alphabétique (doubles crochets) "
fi
 
if [ $a \> $b ] ; then 
   echo "Les opérateurs \< et \> signifient avant et après selon l'ordre alphabétique (simples crochets) "
fi
OK L'opérateur < fonctionne avec les chaînes de caractère
Les opérateurs < et > signifient avant et après selon l'ordre alphabétique (doubles crochets)
Les opérateurs \< et \> signifient avant et après selon l'ordre alphabétique (simples crochets) 
Avec les commandes [ ou test, les primitives < et > doivent être protégées.
(Voir Comparaison lexicographique avec [ ou test.)

Mauvais usages

Les deux opérandes sont obligatoires.

test GNU ==  ; echo $?
[[ != LINUX ]]
echo $?
echo $?
bash: test: GNU : opérateur unaire attendu
2
bash: opérateur binaire conditionnel attendu
bash: erreur de syntaxe près de « LINUX »
2

Les espaces entre les opérandes et la primitive sont obligatoires.

[ "GNU Linux"=="LINUX" ] ; echo $?
0

Sans espace entre les opérande et la primitive “GNU Linux”==“LINUX” est compris comme une chaîne de caractère.
N'étant pas nulle, le test n'échoue pas.


<< Précédant : Les opérateurs de test sur les paramètres [url-invalideSuivant » : Les opérateur de test sur les fichiers]

Opérateurs numériques

Les commandes de tests disposent d'opérateurs permettant de réaliser des comparaison numérique.
Voir Comparaison numérique avec [ (ou test) et [[

Tests sur les fichiers

Le shell bash permet d'effectuer aussi des tests sur les fichiers avec la commande interne composée [[ ]] et la commande interne [ ] (associées à if ou non).).

if [[ option $FICHIER ]]
Extrait de la page du manuel de bash section CONDITIONS
Opérateurs Retours :
-a fichier Vrai si le fichier existe.
-b fichier Vrai si le fichier existe et est un fichier spécial bloc.
-c fichier Vrai si le fichier existe et est un fichier spécial caractère.
-d fichier Vrai si le fichier existe et est un répertoire.
-e fichier Vrai si le fichier existe.
-f fichier Vrai si le fichier existe et est un fichier normal.
-g fichier Vrai si le fichier existe et a son bit Set-GID positionné.
-h fichier Vrai si le fichier existe et est un lien symbolique.
-k fichier Vrai si le fichier existe et a son bit « sticky » positionné.
-p fichier Vrai si le fichier existe et est un tube nommé (FIFO).
-r fichier Vrai si le fichier existe et est accessible en lecture.
-s fichier Vrai si le fichier existe et a une taille strictement positive.
-t df Vrai si le descripteur de fichier df est ouvert et se rapporte à un terminal.
-u fichier Vrai si le fichier existe et a son bit Set-UID positionné.
-w fichier Vrai si le fichier existe et est accessible en écriture.
-x fichier Vrai si le fichier existe et est exécutable.
-G fichier Vrai si le fichier existe et appartient au GID effectif du groupe.
-L fichier Vrai si le fichier existe et est un lien symbolique.
-N fichier Vrai si le fichier existe et a été modifié depuis sa dernière lecture.
-O fichier Vrai si le fichier existe et appartient à l'UID effectif de l'utilisateur.
-S fichier Vrai si le fichier existe et est une socket.
fichier_1 -ef fichier_2 Vrai si le fichier_1 et le fichier_2 se rapportent au même périphérique et ont les mêmes numéros d'inœuds.
fichier_1 -nt fichier_2 Vrai si le fichier_1 est plus récent que le fichier_2 (selon les dates de dernière modification) ou si fichier_1 existe et non fichier_2.
fichier_1 -ot fichier_2 Vrai si le fichier_1 est plus ancien que le fichier_2 ou si fichier_2 existe et non fichier_1.

Remarque : L'opérateur -e teste si le fichier existe quelque soit son statut (fichier, répertoire, lien, etc).

Test dans un script

Soit le script mon_script.

script
#!/bin/bash
var1="~/toto"
if [ -f "$var1" ]
then
  echo "le fichier existe !"
else
  echo "fichier non trouvé ! Car il n'y a pas de développement du ~ entre guillemets (simples ou doubles)."
fi
 
var1=~/toto	# Sans guillemets, le ~ est développé.
if [ -f "$var1" ]
then
  echo "le fichier existe ! (Sans guillemets, le développement du ~ c'est réalisé)."
else
  echo "fichier inexistant !"
fi
 
var1="home/hypathie/toto"
if [ -f "$var1" ]
then
  echo "le fichier existe !"
else
  echo "fichier inexistant !"
fi
 
if test -f "$var1"
then
  echo "le fichier existe !"
else
  echo "fichier inexistant !"
fi
touch ~/toto
bash mon_script
rm -v ~/toto
de la commande
fichier non trouvé ! Car il n'y a pas de développement du ~ entre guillemets (simples ou doubles).
le fichier existe ! (Sans guillemets, le développement du ~ c'est réalisé).
le fichier existe !
le fichier existe !
'/home/hypathie/toto' supprimé

Tests en ligne de commande

Tests dans un terminal des commande test et [.

touch ~/toto
 
test -f /home/hypathie/toto
echo $?
 
[ -f ~/toto ]
echo $?
 
rm -v ~/toto
de la commande
0
0
'/home/hypathie/toto' supprimé

Et voilà ! 8-)

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/la-page-man-bash-ii-les-operateurs-lexicographiques.1676896166.txt.gz · Dernière modification: 20/02/2023 13:29 par agp91

Pied de page des forums

Propulsé par FluxBB