Bash
Les fonctions

Syntaxe

• Définissez une fonction avec le mot-clé function :

  function f {
  

  }

• Définir une fonction avec () :

  f(){
  

  }

• Définissez une fonction avec le mot-clé function et () :

  function f(){
  

  }

Fonction simple

Dans helloWorld.sh

#!/bin/bash

# Define a function greet
greet ()
{
    echo "Hello World!"
}

# Call the function greet
greet

En exécutant le script, nous voyons notre message

$ bash helloWorld.sh
Hello World!

Notez que l' approvisionnement d' un fichier avec les fonctions qui les rend disponibles dans votre session actuelle de bash.

$ source helloWorld.sh   # or, more portably, ". helloWorld.sh"
$ greet
Hello World!

Vous pouvez export une fonction dans certains shells afin de l'exposer aux processus enfants.

bash -c 'greet'  # fails
export -f greet  # export function; note -f
bash -c 'greet'  # success

Fonctions avec arguments

Dans helloJohn.sh :

#!/bin/bash

greet() {
  local name="$1"
  echo "Hello, $name"
}

greet "John Doe"

# running above script
$ bash helloJohn.sh
Hello, John Doe

1. Si vous ne modifiez pas l'argument de quelque manière que ce soit, il n'est pas nécessaire de le copier dans une variable local - simplement en echo "Hello, $1" .

2. Vous pouvez utiliser $1 , $2 , $3 , etc. pour accéder aux arguments de la fonction.

   Note: pour les arguments de plus de 9 $10 ne fonctionnera pas (bash le lira comme $ 1 0), vous devez faire ${10} , ${11} , etc.

3. $@ fait référence à tous les arguments d'une fonction:

   #!/bin/bash
   foo() {
     echo "$@"
   }
   
   foo 1 2 3 # output => 1 2 3
   

   Note: Vous devriez pratiquement toujours utiliser des guillemets doubles autour de "$@" , comme ici.

   Si vous omettez les guillemets, le shell développera des caractères génériques (même si l'utilisateur les a spécifiquement cités pour éviter cela) et introduira généralement des comportements indésirables, voire des problèmes de sécurité.

   foo "string with spaces;" '$HOME' "*"
   # output => string with spaces; $HOME *
   

4. pour les arguments par défaut, utilisez ${1:-default_val} . Par exemple:

   #!/bin/bash
   foo() {
     local val=${1:-25}
     echo "$val"
   }
   
   foo     # output => 25
   foo 30  # output => 30
   

5. pour exiger un argument, utilisez ${var:?error message}

   foo() {
     local val=${1:?Must provide an argument}
     echo "$val"
   }
   

Valeur de retour d'une fonction

L'instruction de return dans Bash ne renvoie pas de valeur comme les fonctions C, mais quitte la fonction avec un statut de retour. Vous pouvez le considérer comme le statut de sortie de cette fonction.

Si vous voulez retourner une valeur de la fonction, envoyez la valeur à stdout comme ceci:

fun() {
    local var="Sample value to be returned"
    echo "$var"
    #printf "%s\n" "$var"
}

Maintenant, si vous faites:

var="$(fun)"

la sortie de fun sera stockée dans $var .

Gestion des indicateurs et des paramètres facultatifs

Les fonctions getopts intégrées peuvent être utilisées à l'intérieur de fonctions pour écrire des fonctions adaptées aux indicateurs et aux paramètres facultatifs. Cela ne présente pas de difficulté particulière, mais il faut bien gérer les valeurs touchées par les getopts . Par exemple, nous définissons une fonction failwith qui écrit un message sur stderr et quitte avec le code 1 ou un code arbitraire fourni en paramètre à l'option -x :

# failwith [-x STATUS] PRINTF-LIKE-ARGV
#  Fail with the given diagnostic message
#
# The -x flag can be used to convey a custom exit status, instead of
# the value 1.  A newline is automatically added to the output.

failwith()
{
    local OPTIND OPTION OPTARG status

    status=1
    OPTIND=1

    while getopts 'x:' OPTION; do
        case ${OPTION} in
            x)    status="${OPTARG}";;
            *)    1>&2 printf 'failwith: %s: Unsupported option.\n' "${OPTION}";;
        esac
    done

    shift $(( OPTIND - 1 ))
    {
        printf 'Failure: '
        printf "$@"
        printf '\n'
    } 1>&2
    exit "${status}"
}

Cette fonction peut être utilisée comme suit:

failwith '%s: File not found.' "${filename}"
failwith -x 70 'General internal error.'

etc.

Notez que pour printf , les variables ne doivent pas être utilisées comme premier argument. Si le message à imprimer comprend le contenu d’une variable, il faut utiliser le spécificateur %s pour l’imprimer, comme dans

failwith '%s' "${message}"

Le code de sortie d'une fonction est le code de sortie de sa dernière commande

Prenons l'exemple de cette fonction pour vérifier si un hôte est actif:

is_alive() {
    ping -c1 "$1" &> /dev/null
}

Cette fonction envoie un ping unique à l'hôte spécifié par le premier paramètre de fonction. La sortie et l'erreur de sortie de ping sont toutes les deux redirigées vers /dev/null , donc la fonction ne générera jamais rien. Mais la commande ping aura le code de sortie 0 en cas de succès et non nul en cas d’échec. Comme il s'agit de la dernière commande (et dans cet exemple, la seule) de la fonction, le code de sortie de ping sera réutilisé pour le code de sortie de la fonction elle-même.

Ce fait est très utile dans les instructions conditionnelles.

Par exemple, si l'hôte graucho est graucho , connectez-vous avec ssh :

if is_alive graucho; then
    ssh graucho
fi

Un autre exemple: vérifiez jusqu'à ce que l'hôte graucho soit graucho , puis connectez-vous avec ssh :

while ! is_alive graucho; do
    sleep 5
done
ssh graucho

Imprimer la définition de la fonction

getfunc() {
    declare -f "$@"
}

function func(){
    echo "I am a sample function"
}

funcd="$(getfunc func)" 
getfunc func # or echo "$funcd"

Sortie:

func () 
{ 
    echo "I am a sample function"
}

Une fonction qui accepte les paramètres nommés

foo() {
  while [[ "$#" -gt 0 ]]
  do
    case $1 in
      -f|--follow)
        local FOLLOW="following"
        ;;
      -t|--tail)
        local TAIL="tail=$2"
        ;;
    esac
    shift
  done

  echo "FOLLOW: $FOLLOW"
  echo "TAIL: $TAIL"
}

Exemple d'utilisation:

foo -f
foo -t 10
foo -f --tail 10
foo --follow --tail 10