Sortie et retour

code de sortie

Les fonctions renvoient une valeur, appelée code (ou état) de sortie, qui est l'analogue du code de sortie renvoyé par une commande. Le code de sortie peut être explicitement spécifié par une instruction return, ou par défaut ce sera le code de sortie de la dernière commande de la fonction (0 en cas de succès, une valeur non nulle sinon). Ce code de sortie peut être utilisé dans le script, il est référencé par la variable $?. Ce mécanisme est un moyen efficace pour que les fonctions aient une « valeur de retour » similaire à celle des fonctions C.

return

Termine une fonction. Une commande return ^[105] prend optionnellement un argument de type entier, qui est renvoyé au script appelant comme « code de sortie » de la fonction, et ce code de sortie est affecté à la variable $?.

Exemple 24.7. Maximum de deux nombres

#!/bin/bash
# max.sh : Maximum de deux entiers.

E_PARAM_ERR=250    # Si moins de deux paramètres passés à la fonction.
EGAL=251           # Code de retour si les deux paramètres sont égaux.
#  Valeurs de l'erreur en dehors de la plage de tout paramètre
#+ qui pourrait être fourni à la fonction.

max2 ()            # Envoie le plus important des deux entiers.
{                  # Note: les nombres comparés doivent être plus petits que 257.
if [ -z "$2" ]
then
  return $E_PARAM_ERR
fi

if [ "$1" -eq "$2" ]
then
  return $EGAL
else
  if [ "$1" -gt "$2" ]
  then
    return $1
  else
    return $2
  fi
fi
}

max2 33 34
return_val=$?

if [ "$return_val" -eq $E_PARAM_ERR ]
then
        echo "Vous devez donner deux arguments à la fonction."
elif [ "$return_val" -eq $EGAL ]
  then
    echo "Les deux nombres sont identiques."
else
    echo "Le plus grand des deux nombres est $return_val."
fi  

  
exit 0

#  Exercice (facile) :
#  ------------------
#  Convertir ce script en une version interactive,
#+ c'est-à-dire que le script vous demande les entrées (les deux nombres).

Astuce

Pour qu'une fonction renvoie une chaîne de caractères ou un tableau, utilisez une variable dédiée.

compte_lignes_dans_etc_passwd()
{
  [[ -r /etc/passwd ]] && REPONSE=$(echo $(wc -l   /etc/passwd))
  # Si /etc/passwd est lisible, met dans REPONSE le nombre de lignes.
  # Renvoie une valeur et un statut.
  # Le 'echo' ne semble pas nécessaire mais...
  # il supprime les espaces blancs excessifs de la sortie.
}

if compte_ligne_dans_etc_passwd
then
  echo "Il y a $REPONSE lignes dans /etc/passwd."
else
  echo "Ne peut pas compter les lignes dans /etc/passwd."
fi

# Merci, S.C.

Exemple 24.8. Convertir des nombres en chiffres romains

#!/bin/bash

# Conversion d'un nombre arabe en nombre romain
# Échelle : 0 - 200
# C'est brut, mais cela fonctionne.

# Étendre l'échelle et améliorer autrement le script est laissé en exercice.

# Usage: romain nombre-a-convertir

LIMITE=200
E_ERR_ARG=65
E_HORS_ECHELLE=66

if [ -z "$1" ]
then
  echo "Usage: `basename $0` nombre-a-convertir"
  exit $E_ERR_ARG
fi  

num=$1
if [ "$num" -gt $LIMITE ]
then
  echo "En dehors de l'échelle !"
  exit $E_HORS_ECHELLE
fi  

vers_romain ()   # Doit déclarer la fonction avant son premier appel.
{
nombre=$1
facteur=$2
rchar=$3
let "reste = nombre - facteur"
while [ "$reste" -ge 0 ]
do
  echo -n $rchar
  let "nombre -= facteur"
  let "reste = nombre - facteur"
done  

return $nombre
       # Exercice :
       # ---------
       # Expliquer comment fonctionne cette fonction.
       # Astuce : division par une soustraction successive.
}
   

vers_romain $nombre 100 C
nombre=$?
vers_romain $nombre 90 XC
nombre=$?
vers_romain $nombre 50 L
nombre=$?
vers_romain $nombre 40 XL
nombre=$?
vers_romain $nombre 10 X
nombre=$?
vers_romain $nombre 9 IX
nombre=$?
vers_romain $nombre 5 V
nombre=$?
vers_romain $nombre 4 IV
nombre=$?
vers_romain $nombre 1 I

echo

exit 0

Voir aussi l'Exemple 11.28, « Vérification d'une entrée alphabétique ».

Important

L'entier positif le plus grand qu'une fonction peut renvoyer est 255. La commande return est très liée au code de sortie, qui tient compte de cette limite particulière. Heureusement, il existe quelques astuces pour ces situations réclamant une valeur de retour sur un grand entier.

Exemple 24.9. Tester les valeurs de retour importantes dans une fonction

#!/bin/bash
# return-test.sh

# La plus grande valeur positive qu'une fonction peut renvoyer est 255.

test_retour ()         # Renvoie ce qui lui est passé.
{
  return $1
}

test_retour 27         # OK.
echo $?                # Renvoie 27.
  
test_retour 255        # Toujours OK.
echo $?                # Renvoie 255.

test_retour 257        # Erreur!
echo $?                # Renvoie 1 (code d'erreur divers).

test_retour -151896    #  Néanmoins, les valeurs négatives peuvent être plus
                       #+ importantes.
echo $?                # Renvoie -151896.
# ======================================================
test_retour -151896    #  Est-ce que les grands nombres négatifs vont
                       #+ fonctionner ?
echo $?                # Est-ce que ceci va renvoyer -151896?
                       # Non! Il renvoie 168.
#  Les versions de Bash antérieures à la 2.05b permettaient les codes de retour
#+ au format d'un grand entier négatif.
#  Les nouvelles versions ont corrigées cette faille.
#  Ceci peut casser les anciens scripts.
#  Attention !
# ======================================================

exit 0

Un contournement pour obtenir des « codes de retour » au format entier long est de tout simplement affecter le « code de retour » à une variable globale.

Val_Retour=   #  Variable globale pour recevoir une valeur de retour
              #+ d'une taille trop importante.

alt_return_test ()
{
  fvar=$1
  Val_Retour=$fvar
  return   # Renvoie 0 (succès).
}

alt_return_test 1
echo $?                              # 0
echo "valeur de retour = $Val_Retour"    # 1

alt_return_test 256
echo "valeur de retour = $Val_Retour"    # 256

alt_return_test 257
echo "valeur de retour = $Val_Retour"    # 257

alt_return_test 25701
echo "valeur de retour = $Val_Retour"    #25701

Une méthode plus élégante est de demander à la fonction d'afficher (via echo) son « code de retour » sur stdout et de le capturer par substitution de commandes. Voir la discussion de ceci dans la Section 36.7, « Astuces assorties ».

Exemple 24.10. Comparer deux grands entiers

#!/bin/bash
# max2.sh : Maximum de deux GRANDS entiers.

#  Ceci correspond au précédent exemple "max.sh", modifié pour permettre la
#+ comparaison de grands entiers.

EGAL=0              # Code de retour si les deux paramètres sont égaux.
E_PARAM_ERR=99999   # Pas assez de paramètres fournis à la fonction.
#           ^^^^^^    En dehors de la plage de tout paramètre fourni

max2 ()             # Renvoie le plus gros des deux nombres.
{
if [ -z "$2" ]
then
  echo $E_PARAM_ERR
  return
fi

if [ "$1" -eq "$2" ]
then
  echo $EGAL
  return
else
  if [ "$1" -gt "$2" ]
  then
    retval=$1
  else
    retval=$2
  fi
fi


echo $retval        # Affiche (sur stdout) plutôt que de retourner la valeur.
                    # Pourquoi ?
}


valeur_retour=$(max2 33001 33997)
#               ^^^^             nom de la fonction
#                    ^^^^^ ^^^^^ paramètres fournis
#  C'est en fait une forme de substitution de commandes :
#+ traiter une fonction comme s'il s'agissait d'une commande
#+ et affecter la sortie de la fonction à la variable "valeur_retour".


# ========================= SORTIE ========================

if [ "$valeur_retour" -eq "$E_PARAM_ERR" ]
  then
  echo "Erreur : Pas assez de paramètres passés à la fonction de comparaison."
elif [ "$valeur_retour" -eq "$EGAL" ]
  then
    echo "Les deux nombres sont égaux."
else
    echo "Le plus grand des deux nombres est $valeur_retour."
fi  
  
exit 0

# =========================================================


#  Exercices :
#  ----------
#  1) Trouvez un moyen plus élégant pour tester les paramètres passés à la
#+    fonction.
#  2) Simplifiez la structure du if/then à partir de "SORTIE".
#  3) Réécrire le script pour prendre en entrée des paramètres de la ligne de
#     commande.

Voici un autre exemple de capture de la « valeur de retour » d'une fonction. Le comprendre requiert quelques connaissances d'awk.

longueur_mois () # Prend le numéro du mois en argument.
{                # renvoie le nombre de jours dans ce mois.
moisJ="31 28 31 30 31 30 31 31 30 31 30 31"  # Déclaré en tant que local ?
echo "$moisJ" | awk '{ print $'"${1}"' }'    # Astuce.
#                            ^^^^^^^^^
# Paramètre passé à la fonction   ($1 -- numéro du mois), puis à awk.
# Awk voit ceci comme "print $1 . . . print $12" (suivant le numéro du mois)
# Modèle pour passer un paramètre à un script awl embarqué :
#                                 $'"${script_parametre}"'

#  Besoin d'une vérification d'erreurs pour les paramètres de l'échelle (1-12)
#+ et pour l'année bissextile avec février.
}

# ----------------------------------------------
# Exemple d'utilisation :
mois=4        # avril, par exemple (4è mois).
journees=$(longueur_mois $mois)
echo $journees  # 30
# ----------------------------------------------

Voir aussi l'Exemple A.7, « days-between : Calculer le nombre de jours entre deux dates » et l'Exemple A.37, « Écart-type ».

Exercice : Utiliser ce que nous venons d'apprendre, étendre l'exemple précédent sur les nombres romains pour accepter une entrée arbitrairement grande.

Redirection

Rediriger le stdin d'une fonction

Une fonction est essentiellement un bloc de code, ce qui signifie que stdin peut être redirigé (comme dans l'Exemple 3.1, « Blocs de code et redirection d'entrées/sorties »).

Exemple 24.11. Vrai nom pour un utilisateur

#!/bin/bash
# realname.sh

# À partir du nom utilisateur, obtenir le "vrai nom" dans /etc/passwd.

NBARGS=1         # Attend un arg.
E_MAUVAISARGS=65

fichier=/etc/passwd
motif=$1

if [ $# -ne "$NBARGS" ]
then
  echo "Usage : `basename $0` NOMUTILISATEUR"
  exit $E_MAUVAISARGS
fi  

partie_fichier ()  # Parcours le fichier pour trouver le motif,
                   #+ la portion pertinente des caractères de la ligne.
{
while read ligne  # "while" n'a pas nécessairement besoin d'une "[ condition]"
do
  echo "$ligne" | grep $1 | awk -F":" '{ print $5 }'
      # awk utilise le délimiteur ":".
done
} <$fichier  # Redirige dans le stdin de la fonction.

partie_fichier $motif

# Oui, le script entier peut être réduit en
#       grep MOTIF /etc/passwd | awk -F":" '{ print $5 }'
# ou
#       awk -F: '/MOTIF/ {print $5}'
# ou
#       awk -F: '($1 == "nomutilisateur") { print $5 }' # vrai nom à partir du nom utilisateur
# Néanmoins, ce n'est pas aussi instructif.

exit 0

Il existe une autre méthode, certainement moins compliquée, de rediriger le stdin d'une fonction. Celle-ci fait intervenir la redirection de stdin vers un bloc de code entre accolades contenu à l'intérieur d'une fonction.

# Au lieu de :
Fonction ()
{
 ...
 } < fichier

# Essayez ceci :
Fonction ()
{
  {
    ...
    } < fichier
}

# De façon similaire,

Fonction ()  # Ceci fonctionne.
{
  {
   echo $*
  } | tr a b
}

Fonction ()  # Ceci ne fonctionne pas.
{
  echo $*
} | tr a b   # Un bloc de code intégré est obligatoire ici.


# Merci, S.C.

Note

Le fichier exemple bashrc envoyé par Emmanuel Rouat contient quelques exemples intéressants de fonctions.