Script bash : état de sortie et les tests

• Objet : Script bash : enchaînement de commandes et redirection
• Niveau requis :

  débutant, avisé
• Commentaires :
• Débutant, à savoir : Utiliser GNU/Linux en ligne de commande, tout commence là !.
• Suivi :
  • Création par Hypathie le 18/03/2014
  • Testé par Hypathie le Juin 2014
• Commentaires sur le forum : Lien vers le forum concernant ce tuto ¹⁾

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

Nota : Les autres wiki :

• debuter-avec-les-scripts-shell-bash
• script-bash-variables-arguments-parametres
• modification de variable et de paramètre
• script-bash-enchainement-de-commandes-et-etat-de-sortie
• 
• script-bash-les-tableaux
• script-bash-les-fonctions

Il ne faut pas confondre le code de retour et le résultat d'une commande. Le résultat est ce qui s'inscrit sur la sortie standard.

1. L'exécution de tous programmes et de toutes fonctions renvoie une valeur numérique appelée code de retour.
2. Il est envoyé 0 si tout c'est bien passé lors de l'exécution, et un nombre entre 1 et 255 s'il y a eu une erreur.
3. Pour récupérer le code de retour on utilise le paramètre spécial $?.
4. Il y a des codes de retour particuliers, par exemple :

blabla

echo $?

retour de la commande

127

On peut chercher dans les codes d'erreur de bash que 127 est le code de retour pour les commandes qui n'ont pas pu être trouvées.

L'état de sortie vrai ou faux ( 0 ou autre chose) est utilisé avec :

1. enchaînements conditionnels :
2. les tests ( commande test, [[ ]], if/else, case)

Parmi les opérateurs d'enchaînement de commandes ci-dessous :
(voir : les opérateurs de contrôle)

  ||    &&    ;    <retour-chariot>  

ceux fonctionnant sur le code de retour, sont :

1. l'opérateur et, cmd1 && cmd2 : avec cet opérateur, la commande 2 est exécutée si le code retour de la commande 1 est 0 (c'est-à-dire, si elle a fonctionné).
2. l'opérateur ou, cmd1 || cmd2 : la commande 2 est exécutée si le code de retour de la première est différente de zéro, c'est-à-dire si elle n'a pas fonctionné.

• Exemple :

Soit le dossier “Mon-dossier” non-vide; le dossier “mon-dossier” vide; et le dossier “mondossier” inexistant.

script

#!/bin/bash
cd ~/Mon-dossier && ls # => titi  toto
cd ~/mon-dossier || pwd # pas de retour : la première commande renvoie 0 
			# car "rester sur place" n'est pas une erreur
cd ~/mondossier 2>/dev/null ||\
 echo "le dossier mondossier n'existe pas" &&\
 read -p "voulez-vous le créer [oui/non] ? " reponse &&\
 ( [ $reponse == non ] && echo " le dossier ne sera pas créé") ||\
 ( [ $reponse == oui ] && echo " le dossier va être créé" ) #; && mkdir ~/mondossier 

Les antislash ne sont pas obligatoires, ils servent à rendre plus lisible les longues commandes qui se suivent sur une ligne.
On inhibe là le <retour-chariot> !

! commande

• Exemple :

whoami

echo $?  

retour de la commande

 0

! whoami

echo $?  

retour de la commande

1

• Syntaxe : exit nombre

Avec un nombre de 1 à 3 chiffre(s).

exit permet de remplacer le code de retour de la dernière commande d'un script.

• Exemples :

Dans ce script, puisque la correspondance est juste, la commande “exit 1” est exécutée, et on sort du programme.

mon-script

var=bonjour
if [ $var == bonjour ] ; then
	echo "$var est correspond à bonjour"	
	exit 1
fi

bonjour est correspond à bonjour

./mon-script

echo $?

retour de la commande

1

script

#!/bin/bash
var=bonjour
if [ $var == coucou ] ; then
	echo "$var est correspond à coucou"	
	exit 0
else
	echo "$var ne correspond pas à coucou"
	echo $?
	exit 1
	echo $?
fi
echo "$var"

bonjour ne correspond pas à coucou
 0

Lançons ce script avec aucun argument ou un autre que “a”.

script

#!/bin/bash
if [[ $1 == a ]] ; then 
	exit 1
fi
 
echo "On a pas utilisé le bon argument, le test n'a pas permis d'exécuter exit"
exit 0

On a pas utilisé le bon argument, le test n'a pas permis d'exécuter exit

Par convention on finit un script par exit 0

Si on ne finit pas par exit 0, il s'exécute un exit $? par défaut, ce qui est équivalent à un exit (tout court).

script

#!/bin/bash
var=bonjour
echo "$var"
echho " " 2>/dev/null # affichage d'erreur vers le puits
echo $?
exit 13

bonjour
127

• Ou encore :

echo $?

retour de la commande

13

• les opérateurs lexicographiques et leur syntaxe
• les opérateurs de comparaison numérique et leur syntaxe
• La commande test ou les crochets :conclusion-sur-les-operateurs-lexicographiques-et-les-operateurs-de-comparaison-numerique

De même que la composition de commandes vu plus haut, on se sert de la composition avec les tests. Et oui les doubles crochets et la commande test sont des commandes !

• séquentielle : cmd1 ; cmd2

• parallèle : cmd1 & cmd2

• sur erreur (ou) : cmd1 || cmd2

• sur succès (et) : cmd1 && cmd2

• rappel des options des commandes de test :

1. -z $chaine : teste si la variable ne contient rien

1. -n $chaine : teste si la variable contient quelque-chose

script

#!/bin/bash
#var3 est nulle, non déclarée, (ou non initialisée) : sa valeur est nulle
#var2 est initialisée mais sans valeur : sa une valeur vide
var1=ma_variable
var2=
var2bis=" "
 
[ ${var1} ] && echo "$var1"    # => ma_variable
[ -n ${var1} ] && echo "$var1" # => ma_variable
[ -n $var1 ] && echo "$var1"   # => ma_variable
#ou encore :
test $var1 && echo "ok"        # => ok
test -n $var1 && echo "ok var1 contient quelque-chose" # => ok var1 contient quelque-chose
test -z $var1 || echo "NON: var1 ne contient pas rien" # => NON: var1 ne contient pas rien
echo " "
 
[ -z $var2 ] && echo "var2: ${#var2} a une valeur vide : ne contient rien" # => var2: 0 a une valeur vide : ne contient rien
[ -n $var2 ] && echo "var2: une valeur vide contient 0 : du vide !" # => var2: une valeur vide contient 0 : du vide !
[ -z $var2bis ] && echo "var2bis: comme var2"  # => var2bis: comme var2
[ -n $var2bis ] && echo "var2bis: comme var2" # => var2bis: comme var2
echo " "
[ -n $var3 ] && echo "ET avec -n: une variable nulle contient aussi du vide" # => ET avec -n: une variable nulle contient aussi du vide
[ -n $var3 ] || echo "OU avec -n"  # PAS DE RETOUR puisque la première commande a renvoyé le code de retour 0.
[ -z $var3 ] && echo " OU avec -z une variable nulle contient aussi du vide" # => OU avec -z une variable nulle contient aussi du vide
[ -z $var3 ] || echo " OU avec -z" # PAS DE RETOUR puisque la première commande a renvoyé le code de retour 0.

• syntaxe de case :

case $variable in
     expression)
         instructions
         ;;
     ...
esac    

• Explications :

1. case “teste” la valeur du paramètre passé au script avec chaque “expression” ;
2. et en fonction de la réussite ou de l'échec du test, il y a exécution ou non des commandes placées au niveau de “instructions” ;
3. Case sert à conditionner l'exécution des commandes en fonction d'argument choisi ;
4. On se sert de “l'étoile” pour permettre que soit exécuter quelque chose quand n'importe quel autre paramètre que ceux des expressions, est passé au script;

• Ne pas oublier :

1. le double point virgule qui permet de clôturer chaque test ;
2. esac pour finir.

• exemple :

script

#!/bin/bash
# passer le paramètre 'coco' à ce script ; puis 'cucu' ; titi puis toto, puis celui que voulez.
case $1 in
	coco)
		echo "Vous avez passé le paramètre 'coco', ré-essayez avec 'cucu'"
	;;
	cucu)
		echo "Vous avez passé le paramètre 'cucu'"
		echo "un peu d'humour !"
		echo "Ré-essayé avec titi, puis avec toto."
	;;
	titi|toto)
		echo "vous avez passé le paramètre $1"
	;;
	*)
		echo "Vous avez choisi $1"	
esac

Vous avez tout en mains pour comprendre ceci : Fonctionnalités avancées du Shell: selecteur-case

Voir structure conditionnelle if pour ce qui suit.

Ci-dessous, les valeurs de la variable1 (var1) et de la variable2 (var2) peuvent être les arguments passés au script. (Lancez “mon-script” successivement sans argument, puis un, deux trois, etc. arguments.)

script

#!/bin/bash
var1=$1
var2=$2
echo $1
echo $2
if [ $# == 1 ] ; then
 echo "ERREUR: vous avez entré $@, mais il faut deux arguments !"
  elif [ $# == 2 ] ; then
   echo "Les deux arguments que vous avez entré sont $1 et $2"
  elif [ $# == 0 ] ; then
    echo "ERREUR: vous n'avez pas entré d'arguments, il en faut deux !"
fi

Avec la structure conditionnelle if, on peut aussi faire des tests sur la (les) valeur(s) déclarée(s) dans le script.

script

#!/bin/bash
var1=23
var2=36
 
if [ $var1 -eq $var2 ] ; then
	echo "$var1 et $var2 sont égales"
else 
	echo "$var1 et $var2 ne sont pas égales"
fi
 
if [ $var1 != $var2 ] ; then
	echo "$var1 et $var2 sont inégales"
fi
 
if [ ${#var1} = ${#var2} ] ; then
	echo "$var1 et $var2 sont des chaînes de même longueur"
fi
echo "les longueurs sont de : ${#var1} et de : ${#var2}" 

script-bash-les-tableaux