Shell Scripting Část V:Funkce v Bash

Ahoj! Vítejte v sérii výukových programů skriptování shellu HowToForge. Pokud si chcete přečíst předchozí verze výukového programu, klikněte sem pro část 1, část 2, část 3 a část 4 výukového programu. V této části se naučíte, jak efektivně strukturovat vaše skripty vytvářením funkcí. Na konci tohoto kurzu budete vědět, jak vytvářet funkce v Linux Bash Shell, předávat parametry funkcím a vracet některé hodnoty z funkce do hlavního kódu. Začněme!

Úvod

Funkce, v programovacích jazycích také známá jako podprogram, je sada instrukcí, která provádí konkrétní úlohu pro hlavní rutinu [1]. Umožňuje programátorům rozdělit komplikovaný a zdlouhavý kód na malé části, které lze volat kdykoli je potřeba. Každá funkce musí být volána hlavní rutinou, aby mohla běžet, takže je izolována s ostatními částmi vašeho kódu, což vytváří snadný způsob testování kódu. Kromě toho lze funkce volat kdykoli a opakovaně, což vám umožňuje znovu používat, optimalizovat a minimalizovat vaše kódy. Jako většina programovacích jazyků i bash shell podporuje funkce.

Obecná syntaxe:

1. Syntaxe 1:

   function function_name
   {
       ##### sada příkazů
   }

2. Syntaxe 2:

   function_name()
   {
       #### sada příkazů
   }

Vytváření funkcí

Bash podporuje dvě struktury funkcí. Při použití první syntaxe musíte použít funkci klíčového slova, za kterou následuje název vaší funkce a otevřít a zavřít závorky a složené závorky, abyste oddělili obsah vašich funkcí od vaší hlavní rutiny. Tato syntaxe vám bude povědomá, pokud máte zázemí v PHP, protože funkce v PHP jsou deklarovány stejným způsobem. Druhá syntaxe se skládá pouze z názvu funkce, otevřených a zavřených závorek a složených závorek.

#!/bin/bash
myfunction(){
    echo "Moje funkce funguje!"
}
myfunction

V našem příkladu jsem použil druhou syntaxi. Po vytvoření funkce myfunction byla poté vyvolána voláním názvu její funkce do naší hlavní rutiny. Hlavní rutina bude kdekoli v našem skriptu, který nebyl definován jako součást naší funkce.

Nyní přeuspořádáme náš kód, abychom otestovali, zda lze funkce deklarovat kdekoli v našem skriptu. Zvažte kód níže:

#!/bin/bash
echo "testování mé funkce"
moje funkce

myfunkce(){
    echo "Moje funkce funguje!"
}

Řádek 3 ve výše uvedeném kódu vrací chybu příkaz nenalezen. Znamená to pouze, že:

Funkce funguje pouze v případě, že je deklarována před vaší hlavní rutinou. Překladač vrátí chybu, pokud jste svou funkci deklarovali po hlavní rutině.

Restrukturalizace kódů pomocí funkcí

Jednou z nejlepších vlastností funkcí je možnost opětovného použití kódů. Pokud procedura vyžaduje opakované spouštění příkazů, ale nelze ji strukturovat pomocí příkazů s opakováním, pak může být řešením funkce.

Zvažte například kód níže:

#!/bin/bash
while(true)
do
    clear
    printf "Vyberte si z následujících operací:\n"
    printf "[a ]ddition\n[b]Odčítání\n[c]Násobení\n[d]Dělení\n"
    printf "#################### ###########\n"
    přečíst -p "Vaše volba:" volba
    případ $volba v
    [aA])
        přečíst -p "Zadejte první celé číslo:" int1
        read -p "Zadejte druhé celé číslo:" int2
         res=$((int1+int2))
 
    ;;
    [ bB])
        read -p "Zadejte první celé číslo:" int1
        read -p "Zadejte druhé celé číslo:" int2
    res=$((int1-int2))
 
    ;;
    [cC])
        read -p "Zadejte první celé číslo:" int1
        read -p "Zadejte druhé celé číslo:" int2
         res=$(( int1*int2))
 
    ;;
    [dD])
        read -p "Zadejte první celé číslo:" int1
        read -p "Zadejte druhé celé číslo:" int2
        res=$((int1/int2))
 
    ;;
    *)
        res=0
        echo "špatná volba!"
    esac

    echo "Výsledek je:" $res
    přečíst -p "Přejete si pokračovat? [y]es nebo [n]o:" ans
    if [ $ans =='n' ]
        potom
         echo „Ukončení skriptu. Přeji hezký den!"
        přestávka
    jinak
         pokračovat
    fi

hotovo

Skript běží dobře, ale všimněte si, že řádky pro přijímání vstupů jsou opakovaně prováděny v každém vzoru v našem příkazu switch.

#!/bin/bash
inputs(){
     read -p "Zadejte první celé číslo:" int1
    read -p "Zadejte druhé celé číslo:" int2
} 

exitPrompt(){
    read -p "Přejete si pokračovat? [y]es nebo [n]o:" ans
    if [ $ans =='n ' ]
    potom
        echo „Opouštím scénář. Přeji hezký den!“
        přestávka
    ostatně
        pokračovat
    fi
}

while(true)
    do
    clear
    printf "Vyberte si z následujících operací:\n"
    printf "[a]Přidání\n[b] Odečítání\n[c]Násobení\n[d]Dělení\n"
    printf "########################### ####\n"
    přečíst -p "Vaše volba:" volba

    případ $volba v
    [aA])
        vstupy
        res =$((int1+int2))
    ;;

    [bB])
         vstupy
        res=$((int1-int2))
;;

    [cC])
         vstupy
        res=$((int1*int2))
    ;;

    [dD] )
        vstupy
        res=$((int1/int2))
    ;;

    *)
        res=0
        echo „špatná volba!“
    esac 

    echo "Výsledek je:" $res
    exitPrompt
hotovo

Vylepšili jsme náš kód vytvořením podsekcí inputs a exitPrompt. Funguje to úplně stejně jako náš předchozí kód, ale s naším současným kódem se snáze řeší problémy, protože je správně strukturován.

Předávání parametrů funkcím

Jako většina programovacích jazyků můžete předávat parametry a zpracovávat tato data ve funkcích v bash. Níže uvedený kód ukazuje postup, jak předat hodnoty ve skriptování shellu:

#!/bin/bash
myfunction(){
    echo $1
    echo $2
}

moje funkce "Ahoj" "Svět" 

 
 

 Všimněte si, že v našem příkladu jsme přidali hodnoty "Hello" a "World" poté, co jsme zavolali myfunction. Tyto hodnoty jsou předány funkci myfunction jako parametry a uloženy v lokální proměnné. Na rozdíl od jiných jazyků však interpret ukládá předané hodnoty do předdefinovaných proměnných, které jsou pojmenovány podle pořadí předávání parametrů, 1 jako počáteční název až po pořadí předávání. Všimněte si, že slovo "Ahoj" je uloženo v proměnné 1 a hodnota "World" je uložena v proměnné 2.
 

 Poznámka:1 a 2 v našem příkladu jsou lokální proměnné, a proto nejsou přístupné pro jiné části skriptu kromě funkce, kde se předávají parametry.
 

 Například,
 
#!/bin/bash
myfunction(){
    echo $1
    echo $2
}

moje funkce "Ahoj" "Svět"
echo $1
echo $2
 

 
 

 Echo $1 a echo $2 v posledních dvou řádcích našeho skriptu se nezobrazují, protože interpret nerozpozná obě proměnné, protože jsou obě lokální pro myfunction.
 
Vrácení hodnot z funkcí
 

 Kromě vytváření funkcí a předávání parametrů jim mohou bash funkce předávat hodnoty lokální proměnné funkce do hlavní rutiny pomocí klíčového slova return. Vrácené hodnoty se pak uloží do výchozí proměnné $? Zvažte například následující kód:
 
#!/bin/bash
add(){
    sum=$(($1+$2))
    vrátit $sum
}

read -p "Zadejte celé číslo:" int1
read -p "Zadejte celé číslo:" int2
přidejte $int1 $int2
echo "Výsledek je:" $?
 

 
 

 V příkladu předáme parametry int1 a int2 funkci add. Dále to funkce add zpracuje přes řádek sum=$(($1+$2)). Poté je hodnota proměnné součtu předána hlavní rutině pomocí řádku return $sum. Ve výchozím nastavení se hodnoty $sum budou ukládat do výchozí proměnné $? Nakonec řádek echo "Výsledek je:" $? vytiskne výsledek.
 
Poznámka:Skripty prostředí mohou vracet pouze jednu hodnotu.
 

 Na rozdíl od jiných programovacích jazyků nemohou skripty shellu vracet více hodnot z funkce. Podívejme se na tento příklad:
 
#!/bin/bash
add(){
    sum=$(($1+$2))
    dif=$(($1-$2))
    návrat $sum 
}

read -p "Zadejte celé číslo:" int1
read -p "Zadejte celé číslo:" int2
přidejte $int1 $int2
echo "Výsledek je:" $?
echo "Výsledek je:" $?
 

 
 
Abych to shrnul
 

 Ukažme si další příklad, který používá funkce, předává mu parametry a vrací hodnotu.
 
#!/bin/bash
#####################
#Autor:HowtoForge #
### ##################
 
clear(){
    clear
}

bin( ){
    bin1=$(echo "obase=2;$1"|bc)
    echo $bin1
}

dec(){
    dec1 =$(echo "ibase=2;$1"|bc)
    návrat $dec1
}

########Hlavní####### ##
    printf "Vyberte si z následujících operací:\n[1]Převod z desítkové soustavy na binární\n"
    printf "[2]Převod z binární soustavy na desítkovou\n"
    přečíst -p " Vaše volba:" op
    case $op in

    1)
        read -p "Zadejte celé číslo:" int
         bin $int
    ;; 

    2)
        read -p "Zadejte binární číslo:" int
        dec $int
        echo "Desetinný ekvivalent $int je $?"
    ;;

    *)
        echo „Špatná volba!“
    esac
 

 
 

 
 

 Uvedený příklad převede daný vstup na binární nebo desítkovou hodnotu pomocí příkazů obase a ibase. Řádek $(echo "obase=2;$1"|bc) převede danou desítkovou hodnotu na binární číslici a uloží ji do proměnné bin1. Dále jsme zobrazili hodnotu $bin1 pomocí příkazu echo.
 
Poznámka:Při převodu z desítkové soustavy na binární je lepší použít přímo echo, protože když vrátíte příkaz k předání binární hodnoty, bash převede binární hodnotu na desítkovou, než ji vrátí.
 

 Navíc jsme binární hodnotu převedli na desítkovou pomocí příkazu $(echo "ibase=2;$1"|bc).
 

 Musíte také pamatovat na to, že interpret je schopen přijímat pouze 8bitové binární číslice. Zadáte číslici, která překračuje limit 8 bitů, dojde k přetečení a nejvýznamnější bit číslice bude vyřazen.
 

 10bitová binární číslice 1000001010 vrátí 10, protože podle 8bitového pravidla budou zbývající 2 bity na pravé straně (nejvýznamnější bit) vynechány, takže 1000001010 se bude rovnat 00001010, což se rovná 10. chcete operaci, která přijímá binární číslice přesahující 8 bitů, pak musíte vytvořit kód ručně.
 
Závěr
 

 Bash má funkce, které jsou velmi podobné programovacím jazykům, aby poskytly uživateli četné nástroje a zvýšily výkon systémů Linux. V této sérii jste rozšířili své znalosti o skriptování shellu pomocí funkcí. Funkce ve skriptech shellu poskytující uživateli modularitu, což usnadňuje odstraňování problémů se skripty a umožňuje opětovné použití kódu.