Ez a cikk bemutatja, hogyan használják és hozzák létre a helyi változók függvényeit a Bash-ban. A Bash függvények létrehozása lehetővé teszi a kód strukturálisabbá tételét, a helyi változók pedig elősegítik a biztonságot és a kódolási hibák elkerülését. Alá merülni!
Mik Bash funkciók?
A többi kódoló nyelvhez hasonlóan a Bash lehetővé teszi funkciók létrehozását a kódból vagy a szkriptből. A függvény meghatározható egy adott feladat vagy feladatsor elvégzésére, és könnyen és könnyen meghívható a fő kódból, egyszerűen a függvénynek adott név használatával.
Ezenkívül beágyazhatja a függvényhívásokat (egy függvény meghívása egy másik függvényen belül), használhat helyi változókat a függvényen belül, sőt a változókat oda-vissza átadhatja függvényekkel vagy globális változók segítségével. Fedezzük fel.
Egyszerű Bash funkció
A test.sh-t a szövegszerkesztőnkkel definiáljuk az alábbiak szerint:
#!/bin/bash
welcome(){
echo "welcome"
}
welcome
Ezt követően ezt a fájlt futtathatóvá tesszük az execute (x) tulajdonságot, és hajtsa végre a parancsfájlt:
chmod +x test.sh ./test.sh
Láthatjuk, hogy a szkript hogyan határozza meg először a welcome() funkció a Bash idiómák használatával function_name(), és {…} funkció burkolók. Végül üdvözlőnek hívjuk a függvényt, egyszerűen a nevének használatával, welcome.
A parancsfájl végrehajtásakor a háttérben az történik, hogy a függvénydefiníciót megjegyzik, de átugrják (azaz nem hajtják végre), amíg kissé lejjebb nem kerül a függvényhívás welcome és a Bash-tolmács melyik ponton hajtja végre a welcome függvény és közvetlenül a függvény utólagos hívása után tér vissza a sorra, ami ebben az esetben a szkriptünk vége.
Változók átadása a Bash függvényeknek
A test2.sh fájlt a kedvenc szövegszerkesztőnkkel (vi;) definiáljuk az alábbiak szerint:
#!/bin/bash
if [ -z "${1}" ]; then
echo "One option required!"
exit 1
fi
func1(){
echo "${1}"
}
func2(){
echo "${2} ${1}"
}
func1 "${1}"
func2 "a" "b"
Ismét futtathatóvá tesszük a szkriptünket a használatával chmod +x test2.sh és ugyanezt hajtja végre.
A kapott kimenet elsőre érdekesnek, sőt zavarónak tűnhet. Ez azonban logikus és könnyen követhető. A szkriptnek átadott ököl opció globálisan elérhető lesz a kódból, mint ${1}, kivéve a belső funkciókat, ahol ${1} lesz a függvénynek átadott első paraméter, ${2} a második stb.
Más szavakkal, a globális ${1} változó (a parancssorból a parancssorból átadott első opció) nem érhető el a függvényeken belül, ahol a ${1} változó változik a függvényhez átadott első opción. Gondoljon a hierarchiára, vagy gondolkodjon el arról, hogy a függvény miként jelenhetne meg egy kis szkript önmagában, és ennek hamarosan lesz értelme.
Sidenote-ként is lehetne használni $1 ahelyett ${1}, de bátorítom a törekvő Bash-kódolókat, hogy mindig vegyék körül a változó neveket { és }.
Ennek oka az, hogy néha, amikor például egy változóban használnak változókat, a Bash tolmács nem képes lát ahol egy változó véget ér, és a szomszédos szöveg egy része a változó név részének tekinthető, ahol nem, váratlan kimenethez vezet. Az is tisztább és világosabb, hogy mi a szándék, főleg ha tömbökről és speciális opciós zászlókról van szó.
Így a globális programmal indulunk ${1} változó értéke "first". Ha megnézi a hívását func1, látni fogja, hogy ezt a változót átadjuk a függvénynek, így a ${1} a függvény belsejében bármi lesz a ${1} a program, azaz "first", és ezért valóban az első kimeneti sor first.
Ezután hívunk func2 és két húrt adunk át "a" és "b" a függvényhez. Ezek aztán azzá válnak ${1} és ${2} automatikusan a func2 funkció. A függvényen belül fordítva nyomtatjuk ki őket, és a kimenetünk szépen illeszkedik b a mint a kimenet második sora.
Végül a szkriptünk tetején is elvégezünk egy ellenőrzést, amely biztosítja, hogy egy opció valóban átkerüljön a test2.sh parancsfájl ellenőrzésével "${1}" üres vagy nem használja a -z teszt a if parancs. A szkriptből nem null kilépési kóddal lépünk ki (exit 1) annak jelzésére a hívó programok számára, hogy valami nem stimmelt.
Helyi változók és visszatérő értékek
Utolsó példánkhoz a test3.sh parancsfájlt a következőképpen definiáljuk:
#!/bin/bash
func3(){
local REVERSE="$(echo "${1}" | rev)"
echo "${REVERSE}"
}
INPUT="abc"
REVERSE="$(func3 "${INPUT}")"
echo "${REVERSE}"
Ismét futtathatóvá tesszük és végrehajtjuk a szkriptet. A kimenet az cba amire a kód átvizsgálásával és a változónevek stb.
A kód azonban bonyolult és kissé megszokja. Fedezzük fel.
Először meghatározunk egy függvényt func3 amelyben létrehozunk egy nevű helyi változót REVERSE. Egy alhéj ($()), és ezen alhéjon belül visszhangozzuk azt, amit a függvénynek átadtak (${1}) és csövezzük ezt a kimenetet a rev parancs.
A rev a parancs a csövön (vagy más módon) kapott bemenetet fordítva nyomtatja ki. Szintén érdekes itt megjegyezni, hogy a ${1} változó az alhéjban marad! Integrálisan elmúlt.
Ezután még mindig a func3 funkcióval kinyomtatjuk a kimenetet. Ez a kimenet azonban nem kerül elküldésre a képernyőn, hanem inkább maga a függvényhívásunk rögzíti, és így a ‘globális’ REVERSE változó.
Beállítottuk a bemenetünket "abc", hívja a func3 funkció újra egy alhéjból, átadva a INPUT változót, és rendelje a kimenetet a REVERSE változó. Ne feledje, hogy a ‘globális’ REVERSE változó és a helyi REVERSE változó a szkriptben.
Míg bármely globális változó, beleértve bármelyiket FORDÍTOTT átkerül a függvénybe, amint megadunk egy helyi változót ugyanazzal a névvel, akkor a helyi változót kell használni. Be tudjuk bizonyítani és megnézhetjük ezt az újabb kis script4.sh parancsfájlt is:
#!/bin/bash
func3(){
local REVERSE="$(echo "${1}" | rev)"
echo "${REVERSE}"
}
INPUT="abc"
REVERSE="test"
func3 "${INPUT}"
echo "${REVERSE}"
A végrehajtáskor a kimenet cba és test. A cba ez az idő ugyanaz generálja-e echo "${REVERSE}" benne func3 függvény, de ez az idő közvetlenül a kimenet, ahelyett, hogy az alábbi kódban rögzítve lenne func3 "${INPUT}" A függvényt nem egy alhéjból hívják meg.
Ez a szkript két tanulási pontot emel ki, amelyekre korábban kitértünk: először is arra, hogy – annak ellenére is, hogy beállítottuk a REVERSE változó "test" a szkript belsejében, mielőtt felhívná a func3 függvény – hogy az helyi változó REVERSE átveszi, és a ‘globális’ egy.
Másodszor, hogy a mi ‘globális’ REVERSE változó megtartja az értékét annak ellenére, hogy volt egy helyi azonos nevű változó a meghívott függvényen belül func3.
Csomagolás
Mint látható, a Bash függvények, a változók átadása, valamint a helyi és félig globális változók használata sokoldalúvá, könnyen kódolhatóvá teszi a Bash szkript nyelvét, és lehetõséget nyújt jól strukturált kód meghatározására.
Figyelemre méltó itt az is, hogy a jobb kódolvashatóság és az egyszerű használat mellett a helyi változók használata további biztonságot nyújt, mivel a változók nem lesznek elérhetők a függvény kontextusán kívül stb. Élvezze a funkciókat és a helyi változókat, miközben kódol a Bash-ban!
Ha többet szeretne megtudni a Bash-ról, fizessen a mi oldalunkra A fájlnevek helyes elemzése a Bash fájlban, és Az xargs használata a bash -c kombinációban komplex parancsok létrehozásához.
