Bash
functies

Syntaxis

• Definieer een functie met het function :

  function f {
  

  }

• Definieer een functie met () :

  f(){
  

  }

• Definieer een functie met zowel het function als () :

  function f(){
  

  }

Eenvoudige functie

In helloWorld.sh

#!/bin/bash

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

# Call the function greet
greet

Bij het uitvoeren van het script zien we onze boodschap

$ bash helloWorld.sh
Hello World!

Merk op dat inkoop een bestand met functies maakt ze beschikbaar zijn in uw huidige bash-sessie.

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

U kunt een functie in sommige shells export , zodat deze wordt blootgesteld aan onderliggende processen.

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

Functies met argumenten

In helloJohn.sh :

#!/bin/bash

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

greet "John Doe"

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

1. Als u het argument op geen enkele manier wijzigt, hoeft u het niet naar een local variabele te kopiëren - echo "Hello, $1" gewoon echo "Hello, $1" .

2. U kunt $1 , $2 , $3 enzovoort gebruiken om toegang te krijgen tot de argumenten in de functie.

   Opmerking: voor argumenten zal meer dan 9 $10 niet werken (bash zal het lezen als $ 1 0), je moet ${10} , ${11} enzovoort doen.

3. $@ verwijst naar alle argumenten van een functie:

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

   Opmerking: gebruik praktisch altijd dubbele aanhalingstekens rond "$@" , zoals hier.

   Het weglaten van de aanhalingstekens zal ervoor zorgen dat de shell jokertekens uitbreidt (zelfs wanneer de gebruiker ze specifiek heeft aangehaald om dat te voorkomen) en in het algemeen ongewenst gedrag en mogelijk zelfs beveiligingsproblemen introduceert.

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

4. gebruik voor standaardargumenten ${1:-default_val} . bv:

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

5. om een argument te vereisen, gebruik ${var:?error message}

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

Retourwaarde van een functie

De return instructie in Bash retourneert geen waarde zoals C-functies, maar verlaat de functie met een retourstatus. Je kunt het zien als de exitstatus van die functie.

Als u een waarde uit de functie wilt retourneren, stuurt u de waarde als volgt naar stdout :

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

Nu, als u dat doet:

var="$(fun)"

de output van fun wordt opgeslagen in $var .

Omgaan met vlaggen en optionele parameters

De getopts ingebouwde kan worden gebruikt in functies om functies te schrijven die geschikt zijn voor vlaggen en optionele parameters. Dit vormt geen speciale moeilijkheid, maar men moet op de juiste manier omgaan met de waarden die door getopts worden aangeraakt. Als voorbeeld definiëren we een failwith- functie die een bericht schrijft op stderr en wordt afgesloten met code 1 of een willekeurige code die wordt geleverd als parameter voor de optie -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}"
}

Deze functie kan als volgt worden gebruikt:

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

enzovoorts.

Merk op dat wat printf betreft , variabelen niet als eerste argument mogen worden gebruikt. Als het af te drukken bericht bestaat uit de inhoud van een variabele, moet u de %s specificator gebruiken om het af te drukken, zoals in

failwith '%s' "${message}"

De exitcode van een functie is de exitcode van het laatste commando

Overweeg deze voorbeeldfunctie om te controleren of een host actief is:

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

Deze functie verzendt een enkele ping naar de host die is opgegeven met de eerste functieparameter. De uitvoer en foutuitvoer van ping worden beide omgeleid naar /dev/null , dus de functie zal nooit iets uitvoeren. Maar de ping opdracht heeft exitcode 0 bij succes en niet nul bij mislukking. Aangezien dit de laatste (en in dit voorbeeld de enige) opdracht van de functie is, wordt de exitcode van ping opnieuw gebruikt voor de exitcode van de functie zelf.

Dit feit is zeer nuttig in voorwaardelijke uitspraken.

Als host graucho bijvoorbeeld is graucho maak er dan verbinding mee met ssh :

if is_alive graucho; then
    ssh graucho
fi

Een ander voorbeeld: controleer herhaaldelijk tot host graucho is graucho maak er vervolgens verbinding mee met ssh :

while ! is_alive graucho; do
    sleep 5
done
ssh graucho

Druk de functiedefinitie af

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

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

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

Output:

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

Een functie die benoemde parameters accepteert

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"
}

Voorbeeld gebruik:

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