Bash funkciók és helyi változók – CloudSavvy IT

Avatar admin | 2021.01.27. 25 Views 0 Likes 0 Ratings

25 Views 0 Ratings Rate it

Shutterstock

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

Egyszerű Bash funkció

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.

Fejlettebb Bash funkció változó átadással

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.

Példa helyi változókkal és visszatérő értékekkel

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 Bash függvény és a helyi változó példa az eddig látott tanulási pontok közül kettőt szemléltet

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.


Source link


25 Views 0 Ratings Rate it

  • Minden jog fenntartva 2019-2020. Hogyankészítsek.Hu Impresszum Adatkezelési szabályok