Ha, akkor. Talán ez az egyik legjobban használható szerkezet a bash scripteknél. De előbb gondolkodjunk el arról, hogy mik is azok az egyszerű programozói megoldások, amikről szó lesz. Az alapesetben megszokott shell scripteken (felsoroljuk a parancsokat) kissé túllépve felmerül az igény, hogy ne csak robot mód hajtsanak végre parancsokat a scriptek, hanem bizonyos döntéseket, vagy egyéb öntevékeny feladatokat automatizálni lehessen. A döntést a szó alapértelmében értsük. Az első ilyen döntési megoldás, ha a scriptnek megadunk egy feltételt, egy tesztelendő értéket, amit vizsgáljon meg, és ha a feltételnek megfelel a helyzet, akkor hajtson végre egy teendőt. No ez így talán nagyon homályosnak tűnhet de egy példa: ha az általad beírt érték nagyobb mint 100, akkor írja, ki hogy ez bizony nagyobb mint száz. Ez nem tűnik túl nagy dolognak, de maga a tesztelésre megadott kérdés az bármi lehet. A legegyszerűbb ilyen megoldás, ha egy számítógépen vizsgálod valami fizikai paraméter (üres hely, hőfok, memória, terheltség, bármi) értékét egy scriptben, majd ha az elér egy szintet küld egy üzenetet.

Mi az a if-then-fi szerkezet?

Akkor, ha… Azaz egy állítást vizsgál, és ha az megfelelő értéket ad, végrehajtja a parancsot. Egyszerű? Az.
Igen, tudom, hogy az if-then (ha, akkor) szerkezet emlegetik, én pedig a if-then-fi szerkezetet. Miért? Mert a legtöbb ilyen szerkezetnél van egy „lezáró tag” is. Ezt sokszor lehagyják az emberek, és nem mindig tolerálja a script működése ezt. Ahogy a zárójeleknél van nyitó zárójel, és záró zárójel – és azt elvárja a program – úgy itt is fontos, hogy jelezzük a scriptnek, hogy hol van vége, azaz ne maradjon le a végéről az fi!

Alapvető, legegyszerűbb if-then-fi megoldás

Egy állítás, egy teszt/vizsgálat, semmi más.

A szerkezetet érdemes EBBEN a formában lementeni, és csak bemásolni amikor kell. És nem lesz semmi gond!

if [ <tesztelendő állítás> ]
then 
     <parancs, amit végre kell hajtani>
fi

Egy faék egyszerűségű példa:

#!/bin/bash
# Nagy, vagy kicsi? Adj meg paraméternek egy számot!
if [ $1 -gt 100 ]
then
    echo "Ez egy nagy szám!"
    pwd
fi
date

majd mentés, futtatás, egyszer 100-nál kisebb, másodszor 100-nál nagyobb számmal.

Elemezzük ki ezt a gigantikus programot 🙂

if [ $1 -gt 100 ]

if, azaz ha. A kapcsos zárójelben lévő tesztelendő feladat: nézzük meg, hogy az első parancssori argumentum nagyobb-e mint 100. A $1 az első, a script nevét követő kapcsoló, paraméter, argumentum. Ide, mármint az if utáni részbe BÁRMIT írhatsz, amit le tudsz programozni, és ha az igaz, akkor végre akarsz hajtani valamit. Itt már a fantázia kérdése, hogy mit hozol ki ebből.

Then, azaz akkor. Az ezt követő parancsok csak akkor indulnak el, ha a if sor tesztje igaznak bizonyul. Itt meg lehet adni annyi parancsot, amennyit csak akarsz. Szép sorban lefutnak, egymás után. Itt a teszt akkor indítja el ezt a rész, ha a szám nagyobb, mint 100.
Ha az if sor tesztje negatív, azaz jelen esetben a szám kisebb, mint 100, akkor a then utáni, a jobb olvashatóság miatt behúzott részen túllép a script.

Itt fontos, az fi, azaz az if fordítottja. Ezzel mondjuk meg a scriptnek, hogy itt van vége a szerkezetnek, azaz ha elvégezte a munkát, akkor ezután kell folytatni. Ha nem kellett semmit tennie, azaz a vizsgálat, a teszt negatív, akkor a then és az fi közti részt átugorja, a fi jelzi, hogy meddig tart az átugrandó rész.

A date parancs? Mivel ez a parancs az if-then-fi utasításon kívül helyezkedik el, az if teszt eredményétől függetlenül fog futni.

Fontos: ezekre a megoldásokra mindig úgy gondolj, mint egy egységre: legyen eleje és vége. Itt if és fi közti rész az egység.

Tipp: kezdeti időben az ilyen faék egyszerűségű scriptekkel tanuljuk meg, hogy mit is csinál az adott szerkezet. Teszteljük le minden elképzelhető verziót, itt kettő lehetséges kimenetet: egy kisebbel, egy nagyobbal. Figyeljük meg a működését, és az esetleges hibákat. Nagy hiba (sikeresen elkövettem), hogy összetett példákat kerestem, melyeknek valódi haszna is van, és nem figyeltem meg magának a if-then-fi szerkezetnek a működését!

Test Linux parancs = a szögletes zárójelek

A szögletes zárójelek ([]) a ha fenti szerkezetben valójában egy utalás a test parancshoz. Ez azt jelenti, hogy az összes operátor, lehetséges elem, amelyet a test lehetővé tesz, itt is használható. Keresd meg a test man oldalát, hogy megismerd az összes lehetséges operátort. A kínálat viszonylag kicsi, de ezeket viszonylag jól tudjuk használni:

! KIFEJEZÉS Az állítás hamis
-n STRING STRING hossza nagyobb, mint nulla.
-z STRING A(z) STRING hossza nulla (azaz üres). Igen jól tudod ellenőrizni, pld. hogy van-e elvárt paramétere a scriptnek. (1)

STRING1 = STRING2 STRING1 megegyezik a STRING2 értékkel. Egyszerű „jelszó” vagy ismeret ellenőrzése (2)
STRING1! = STRING2 A(z) STRING1 nem azonos a(z) STRING2 értékkel

A példa ezekre épült:
ÉRTÉK1 -eq ÉRTÉK2 Az ÉRTÉK1 számszerűen megegyezik az ÉRTÉK2-vel
ÉRTÉK1 -gt ÉRTÉK2 Az ÉRTÉK1 számszerűen nagyobb, mint az ÉRTÉK2.
ÉRTÉK1 -lt ÉRTÉK2 Az ÉRTÉK1 számszerűen kevesebb, mint az ÉRTÉK2

Fájlok létezésnek ellenőrzése:
-d FÁJL A FILE létezik, és egy könyvtár.
-e FÁJL A fájl létezik. (3)
-r FÁJL A FILE létezik, és az olvasási engedélyt megadták.
-OK FÁJL A FILE létezik, és mérete nagyobb, mint nulla (azaz nem üres).
-W FÁJL A (z) FILE létezik, és az írási engedélyt megadták.
-x FÁJL A FILE létezik, és a végrehajtási engedélyt megadták.

(1)

if [ -z $1 ]
then
    echo "Köllene egy para és méter!!!"
fi

(2)

if [ Laci = $1 ]
then
    echo "Eltaláltad a nevem!"
fi

(3)

if [ -e teszt.sh ]
then
    echo "Van ilyen fájl!"
fi

Megjegyzés: nálam a teszteléskori script neve a teszt.sh. Így kiírja a szöveget, de te adj meg olyant, ami valóban van, és adj egy olyant, ami nincs. Érdemes kissé körbenézni a test parancs használata előtt az interneten sok apróbb példa jól tükrözi a sokoldalúságát.

Bár így önmagában is egy jól használható szerkezet, hiszen egy adott feltétel megléte esetén teszi csak meg a then-t követő utasításokat, de ezzel még nem merítettük ki az összes lehetőségét.

Beágyazott szerkezetek – legózzuk össze az if-then-fi megoldást

Az ilyen egyszerű szerkezeteknél nagyon hasznos tulajdonság, hogy egymásba építhetőek. Azaz nem csak egyszerű ha-akkor összetételt adhatunk meg, hanem ilyent is: Ha nagyobb, mint száz, írd ki, és ha páros, akkor azt is jelezd. Itt már komolyabb átgondolást igényel a szerkezetek egymásutánisága. Nem mindegy, hogy melyik if-else-fi hova kerül! Nézzünk is meg az adott példát kicsit kibővítve:

#!/bin/bash
# Számok tesztje 1

if [ $1 -gt 100 ]
then
    echo ”Hát ez nagy!”

    if (( $1 % 2 == 0 ))
    then
    echo ”Ráadásul páros is!”
    fi
fi

A formázás nem felesleges! Így a „blokkokat” jól láthatjuk. A szám nagyságát ellenőrző részbe beágyaztuk a páros/nem páros ellenőrzését is. Ha nem érted magát a megoldást, hogy miért így kell ezt ellenőrizni, nem gond. Vagy nézz utána, vagy várj egy kicsit, és lesz matekozási rész is. Most az a lényeg, hogy a első  if-then-fi szerkezeten belül van a második  if-then-fi, ami biztosítja, hogy csak akkor fut le a második rész ha az első, „külső” if utáni állítás igaz. Azaz nagyobb, mint 100 ÉS páros is.
Teszteld! Akkor már látod, hogy valóban így jár el.

Most emeljük ki piros részt a burkoló, azaz a zöld blokkból. És legyen egy különálló egység:

#!/bin/bash
# Számok tesztje 2

if [ $1 -gt 100 ]
then
   echo ”Hát ez nagy!”
fi

if (( $1 % 2 == 0 ))
then
   echo ”Ráadásul páros is!”
fi

Így már két, különálló állítást kapunk: az első rész, megnézi, hogy nagyobb mint 100. Majd megteszi a kellő feladatot: kiírja amit kell. Lezárul a fi-vel. Elfelejti ezt a feladatot, hiszen már vége: megnézte a méretet, és vagy igen, vagy nem, majd megtette amit kell. Lép tovább.
Jön a második if-then-fi feladata: megnézi, hogy páros, vagy nem, megteszi, amit kell. De az első feltételt nem vizsgálja, hogy mekkora a szám.
Teszteld!

Ok, miért kellett ezt így szájbarágósan leírni?

Mert nagyon fontos egyrészt az egymásba ágyazhatóság, aminél nem mindegy, hogy hol helyezkedik el a if-then-fi blokk. Másrészt jó példa arra, hogy valóban egy-egy blokként kell tekinteni egy egybetartozó részre és azt (ha lehet) jól láthatóan kell leírni. Szokjuk meg a normális, legalábbis a saját magadnak átlátható behúzások használatát.
Ami pedig már technikai téma: ha csak behányod a kódot egypár sorba, és nem ilyen rendezetten, akkor előfordulhatnak fura hibajelek! Bár a fenti megoldásokat egy sorba is beírhatnánk, mert van rá lehetőség, hogy a határokat ; azaz pontosvesszővel jelöljük, de jobb ha a rendezett kódot szokjuk meg. Igen, lesznek olyanok is, amikor a ; kötelező lesz.

A következő részben még jobban skálázzuk a lehetőségeket ennél a szerkezetnél. Már nem csak „ha igaz, akkor tedd meg” hanem a „ha igaz, akkor ezt tedd, ha nem, akkor azt” variációt is megismerjük. A következő rész július 4-re időzítettem be! Addig találj ki pár ilyen, ha, akkor megoldást magadnak. Nem az a lényeg, hogy hasznos legyen, hanem magának az elvnek a megértése és az egymásba legózhatóság!

Related Posts