A shell vezérlő szerkezetei I.

Átírás

1 Tartalom A shell vezérlő szerkezetei I.. Mit nevezünk vezérlésnek a shell programozásban.... Vezérlési szerkezetek....2 Az igaz/hamis feltétel a shell programozásban Az &&, és! szerkezetek A test és az expr parancs A test Az expr Feltételes végrehajtás if szerkezettel A for ciklusok A while és until ciklusok A break és continue használata A shift parancs Kilépés a shell programból: az exit A read parancs...4. Mit nevezünk vezérlésnek a shell programozásban. Vezérlési szerkezetek A shell programozásban - a klasszikus programnyelvekhez hasonlítva egy "utasításnak" tulajnképpen egy kiatt parancs, illetve parancssor felel meg. Ha parancssorról beszélünk láttuk, hogy ennek szerkezete egy parancsnál több is lehet, például tartalmazhat akár 2 parancsot is csővezetékkel összekötve. Ezért sokszor a végrehajtható egységet csővezeték sorozatnak (pipeline) is nevezik. Ezt a vezérlési szerkezetek megadásánál -nak fogjuk jelölni. Ha a parancs sor valamilyen feltételt is generál, amit gyelembe veszünk, akkor feltétel_ -nak jelöljük. A parancssori szerkezetek végrehajtásának sorrendjét nevezzük vezérlésnek. Erre a shell szintaxisa különböző, úgynevezett vezérlési szerkezetet használ. A strukturált programozás elméletéből tudjuk, hogy egy klasszikus program végrehajtásához egy programozási nyelvnek a változók kezelésén kívül legalább a döntéshelyzeteket (if szerkezetek) illetve a ciklusok kezelését kell megoldania. Ezzel a kettővel bármilyen parancs végrehajtási sorrend megszervezhető. A shell vezérlő szerkezeteit eredetileg az ALGOL68 nyelvet követve alakították ki..2 Az igaz/hamis feltétel a shell programozásban A szerkezetek kialakítása miatt szükségünk van az igaz illetve hamis feltétel fogalmára. Mivel a shell alatt programok, illetve parancsok futnak, a feltételt ezek lefutása után nyert, programok által szolgáltatott visszatérési érték (program exit status) jelenti (egész pontosan ez a C programok kilépése után, az int main() függvény által visszaatt egész szám: ennek értékét a C-ben meghívott void exit(int n) függvény paraméterében adjuk meg). Ez az érték közvetlenül a parancs befejezése után, a parancs által futtatott utolsó program visszatérési értékéből áll, amely bekerül a shell speciális? nevű változójába. Ezt egyszerűen az echo paranccsal tesztelni is lehet:

2 touch.txt ls -l.txt -rw-rw-r-- lszabo lszabo 0 Oct 2 0:00.txt #végrehajtás után kiírhatom a? változót echo? 0 ls -l nemletezik ls: nemletezik: No such le or directory echo? 2 Látható, hogy jó lefutás esetén a visszatérített érték 0, míg hiba esetén eltér 0-tól, jelen esetben 2, de minden esetben egész szám (a számnak általában van pontos jelentése, és azt hogy milyen hibára utal az illető parancs kézikönyv lapján lehet megnézni. Az ls kézikönyve erről ennyit ír: "Exit status is 0 if OK, if minor problems, 2 if serious trouble"). Az is meggyelhető, hogy a teszteléseink logikája pont a fordított lesz a C, Java nyelveknél megszokottnál: itt az "igaz" feltételt a? változó 0 értéke adja. A POSIX szabvány standardizálja a programok által visszaatt értékeket, így ajánlatos ezeket programírásnál betartani. Ez az érték általában egy 255-nél kisebb előjel nélküli egész szám.? értéke Mit jelent? 0 Sikeres parancsvégrehajtás. > 0 Hiba történt a parancssor kiértékelésénél (akár az átirányításokban, behelyettesítésekben is lehet ez) A program lefutott, de hibával lépett ki. 26 A program létezik, de nem lehetett végrehajtani (pl. nincs jogunk hozzá, vagy nem egy végrehajtható bináris kód). 27 A parancs nem létezik (nem lehetett a PATH elérési útjai szerint megtalálni) > 28 A program jelzéssel állt le (pl. ha a cat futása közben lenyomjuk a ^C -t, a program 30-at térít vissza). Megjegyzés: a 28 -as kód jelentése nincs standardizálva. 2. Az &&, és! szerkezetek Az első szerkezet amit átnézünk akár egyetlen parancssoron alkalmazható a meghívott parancsok között. Amint sejthető, az && egy és, míg a egy vagy típusú feltételt fog megoldani az egymásutáni parancsvégrehajtásban. A z &&,, illetve! szerkezeteket rövidre záró operátoroknak is nevezzük (short circuit operators), mert a programozási nyelvekhez hasonlóan, a kiértékelésük leáll, ha egy logikai szerkezet végeredménye valamelyik (pl. az első) parancs végrehajtása után előre tudható. Az alábbi món használhatóak: touch.txt 2

3 ls.txt && echo 'van ilyen fájl'.txt van ilyen fájl #ha nem sikerül az ls-t lefuttatni, kiírok egy üzenetet ls.txt echo 'uzenet'.txt ls nemletezik 2>/dev/null && echo 'uzenet' ls nemletezik 2>/dev/null echo 'uzenet' uzenet Az && szerkezet végrehajtja a parancssoron következő parancsot, amennyiben az előző lefutott parancs "jól" futott le, tehát igaz visszatérített értékkel zárult. Tulajnképpen úgy is tekinthetjük, hogy az && kiértékeli a két lefutott parancs által visszatérített értéket. Logikailag a másodikat akkor értelmes végrehajtani, ha az első parancs jól lefutott. A esetében viszont a második parancsot nincs értelme végrehajtani, ha az első jól futott le, amint az a második példából (ls.txt echo 'uzenet' ) látszik. Ezzel a két egyszerű szerkezettel akár if-else struktúra is kialakítható egyetlen parancssoron két parancs között: ls.txt && echo 'van ilyen fájl' echo 'nincs ilyen fájl'.txt van ilyen fájl ls nemletezik && echo 'van ilyen fájl' echo 'nincs ilyen fájl' ls: nemletezik: No such le or directory nincs ilyen fájl A logikai kiértékelés eredménye a? változóban marad miután az utolsó parancs is lefutott a feltételsorozatból. Így, amint látni fogjuk, a teljes "logikai kifejezés" bonyolultabb feltételek programozására is használható. A! operátornak egy jobb oldalon található parancs operandusa kell legyen, segítségével a visszaatt? változó értéke negálható:! ls *.txt.txt 2.txt felhasznalok.txt echo? 3. A test és az expr parancs 3. A test Az előzőleg lefutott program visszatérési értékén kívül, gyakran tesztelünk: -állományok tulajnságait (létezik-e, írható-e, olvasható-e, stb.) -karakterláncokat (vagy változókat, amelyek karakterláncot tartalmaznak: létezik-e, mennyi az értéke) -számszerű értékeket (számokat tartalmazó karakterláncokat) A három típusú teszt elvégzését egy shell parancsban valósították meg. A parancs argumentumként megkapja a tesztelendő állománynevet, karakterláncot, számot tartalmazó változót, lefut és 3

4 visszatérési értékében közli a teszt igaz vagy hamis voltát, a már említett fordított logikával. A parancsot test -nek nevezik, és megtalálható külső parancs illetve a shell-be épített parancs formájában is (mivel igen gyakran használjuk). A test hívásakor az argumentumok szerkezete különbözik, ha állománynévről, karakterláncról illetve számról van szó. Általánosan ezt így adjuk meg: test kifejezés de az alábbi szintaxissal is hívható: [ kifejezés ] A test az alábbi kifejezéseket fogadja el (a teljes lista megtalálható a man test -ben, itt csak az általunk laboron használt kifejezések találhatóak): Állományok tesztelése: -d le Igaz ha a le létezik és könyvtár. -e le Igaz ha a le létezik. -f le Igaz ha a le létezik és szabályos fájl. -L le Igaz ha a le létezik és szimbolikus hivatkozás (szimbolikus link). -r le Igaz ha a le létezik és olvasható. -s le Igaz ha a le létezik és 0-nál nagyobb méretű. -w le Igaz ha a le létezik és írható. -x le Igaz ha a le létezik és végrehajtható. -O le Igaz ha a le létezik és az aktuális felhasználó tulajnában van. -G le Igaz ha a le létezik és az aktuális csoport tulajnában van. le -nt le2 Igaz ha le újabb (a mósítási időt tekintve), mint le2. le -ot le2 Igaz ha le régebbi, mint le2. le -ef le2 Igaz ha le és le2 -nek azonos eszköz- és i-node számuk van. Karakterláncok tesztelése: -z string Igaz ha a string 0 hosszúságú. -n string string Igaz ha a string nem 0 hosszúságú (kétféleképpen lehet tesztelni). string = string2 4

5 Igaz ha a stringek megegyeznek. string!= string2 Igaz ha a stringek nem egyeznek meg. Logikai tesztek két test kifejezés között:! expr Igaz ha expr hamis. expr -a expr2 Igaz ha expr és expr2 is igaz. (Logikai 'és'.) expr -o expr2 Igaz ha expr vagy expr2 igaz. (Logikai 'vagy'.) Számokat tartalmazó karakterláncok összehasonlítása: Operációs rendszerek I. - UNIX felhasználói ismeretek és héjprogramozás arg OP arg2 az OP operátor valamelyik a következőkből: -eq, -ne, -lt, -le, -gt, -ge. (a rövidítések régebbi programozási nyelvekben voltak használatosak: equal, not equal, less, less or equal, greater, greater or equal stb. műveleteket jelentik). Ezek az aritmetikai operátorok igaz értéket adnak, ha arg rendre egyenlő, nem egyenlő, kisebb mint, kisebb vagy egyenlő, nagyobb mint, nagyobb vagy egyenlő mint arg2. arg és arg2 pozitív vagy negatív egész kell legyen, vagy pedig a - l string speciális kifejezés, amely a sztring hosszát jelenti. A klasszikus (Bourne) shell csak egész számokat tud így összehasonlítani, a Korn shell valósakat is. Álljon itt néhány példa is. A test lefuttatása után azonnal meghívjuk az echo? parancsot, hogy lássuk a teszt eredményét. touch.txt touch 2.txt chmod a-w 2.txt # létezik-e a le test -f.txt ; echo? 0 # könyvtár-e test -d.txt ; echo? # írható-e test -w.txt ; echo? 0 # létrehozok 2 sztringet a='abc' b='def' # a a hossza 0? test -z a ; echo? 5

6 # a egyenlő-e b-vel test a = b ; echo? # létrehozok 2 sztringet amelyek számot tartalmaznak x=2 y=3 # x értéke kisebb mint y? test "x" -lt "y" ; echo? 0 # x értéke kisebb mint? test "x" -lt "" ; echo? Valamennyi esetben a [ ] szintaxissal is hívható a teszt, tehát az utolsó esetre például írhatjuk: [ "x" -eq "y" ] ; echo? Fontos: a test kifejezések minden operandusa és operátora között elválasztó karakter kell legyen (szóköz). 3.2 Az expr Az expr parancsot egyszerű kis műveletek elvégzésére alakították ki shell változók között, mint például két számértéket tartalmazó változó összeadása (amire gyakran van szükség vezérelt végrehajtás során). Ma már ritkábban használják, mert a Korn és Bourne shellnek van jobb megoldása a műveletek elvégzésére és ezt a Bash is átveszi (a (( )) szerkezet). Ennek ellenére, használata előfordul, és kezdetnek, két szám közti művelet elvégzésére megteszi. Az expr tud még karakterláncokkal is műveleteket végezni. Használat: expr kifejezés Az expr a kimenetre írja ki a kifejezés eredményét, és parancssor behelyettesítéssel lehet azt egy másik változóba átvenni. Az expr által elfogatt aritmetikai és logikai kifejezések az alábbiak: ARG ARG2 ARG ha az nem 0 vagy null sztring, egyébként ARG2 ARG & ARG2 ARG ha egyik argumentum sem 0 vagy null sztring, másképp 0 ARG < ARG2 ARG kisebb mint ARG2 ARG <= ARG2 ARG kisebb vagy egyenlő ARG2 ARG = ARG2 ARG egyenlő ARG2 ARG!= ARG2 ARG nem egyenlő ARG2 ARG >= ARG2 ARG nagyobb vagy egyenlő ARG2 6

7 ARG > ARG2 ARG nagyobb ARG2 ARG + ARG2 aritmetikai összeg: ARG + ARG2 ARG - ARG2 aritmetikai különbség ARG - ARG2 ARG * ARG2 aritmetikai szorzat ARG * ARG2 ARG / ARG2 aritmetikai osztás ARG / ARG2 ARG % ARG2 aritmetikai maradéka az ARG / ARG2-nek STRING : REGEXP mintaillesztés a STRING első karakterétől match STRING REGEXP ugyanaz mint a mintaillesztés STRING : REGEXP substr STRING POS LENGTH visszaadja a STRING-ből a LENGTH hosszúságú alsztringet POS-tól kezdve index STRING CHARS visszaadja azt az indexet a STRING-ből ahol bármelyik CHARS halmazban levő karakter található length STRING a STRING hosszát adja vissza Például: expr a=(expr 2 + 3) echo a 5 A második példából látható, hogyan kell átvenni változóba a kiszámított értéket. Az expr használatánál vigyázni kell az olyan műveleti jelekre, amelyek shell metakarakerek is. Ezeket backslash jelöléssel kell használni, mint például a szorzást, mert először a shell értelmezi, és nyílván átírja őket, ha nem használuk a \ -t: expr 3 \* 4 2 Ugyanebbe a kategóriába esnek a <, >, &, jelek. 4. Feltételes végrehajtás if szerkezettel A feltételes végrehajtást az if szerkezettel vezéreljük, amely megoldja, hogy egy bizonyos feltételtől függően egyik vagy másik parancssor legyen végrehajtva. Ez a szerkezet természetesen egy végrehajtott parancs visszatérési értékétől függően dönt a további végrehajtásról. Használata: if feltétel_... else 7

8 ... vagy többszörös feltétel esetén: if feltétel_... elif feltétel_... else... A feltételt jelentő parancssorban bármilyen végrehajtható, akár egyedülálló, akár csővezetékkel összekötött parancs lehet. Leggyakrabban a test parancsot használjuk itt a döntések megvalósítására, de lehet ott bármilyen egyéb parancs is. Példa a test parancs használatára if szerkezetben: ha a fájl írható a felhasználó számára, akkor írok egy sort a végére, másképp hibaüzenetet írok ki: szoveg="utolsó sor a fájl végére" lenev=".txt" #tesztelem, hogy a fájl írható-e if [ -w "lenev" ] echo szoveg >> lenev echo "Szoveg a fájl végére írva!" else echo "lenev" nem írható Figyelem: a test zárójelezésénél a [ ] zárójelek mindkét oldalán egy elválasztó szóközt kell hagyni: if [ -w "lenev" ] # ^ ^ ^ ^ a nyilak fölött szóköz van!!! De használhatok feltételnek egy egyszerű parancsot is, például: belépek az elso könyvtárba, ha az létezik, egyébként hibát írok ki: #megpróbálok belépni az elso könyvtárba if cd elso 2>/dev/null echo "sikerült a könyvtárba lépni." else echo "nincs elso könyvtár." 8

9 Ezekben az esetekben nem mindig van szükségünk a feltételként használt parancs kimenetére vagy hibakimenetére, így ezeket a null eszközre vagy napló állományba irányítjuk. Példa csővezeték használatára a feltételben: #a feltételben egy hosszabb parancsort hívok meg #és elő is állítok egy listát if cat /etc/passwd cut -f -d ":" sort > felhasznalok.txt echo 'megvan a felhasználók listája' else echo 'nem sikerült előállítani a listát' Ugyanakkor az említett &&, illetve! szerkezeteket is használhatjuk a feltétel parancssorán bonyolultabb döntések kivitelezéséhez. Az alábbi szkript törli az.txt állományt ha az írható és a mérete 0 byte: le=".txt" #tesztelem, hogy írható-e a fájl és hossza 0 #a hossz tesztelésénél megnézem, hogy nagyobb-e mint 0 és tagam if [ -w "le" ] &&! [ -s "le" ] rm "le" echo le törolve (a -s operátor igazat ad vissza, ha a fájl hossza nagyobb mint 0 byte). A fenti példában két teszt parancs kimenetén végzünk logikai műveletet. Az if vagy else ág a feltételes végrehajtásnál nem lehet üres (tehát valamit végre kell ott hajtani). Amennyiben a programozás során mégis üres ágat akarunk használni, a shell üres utasítását kell használnunk, a melyet a : szimbólummal hívunk meg: if [ -w "le" ] &&! [ -s "le" ] rm "le" echo le törolve else : 5. A for ciklusok A for ciklus egy listán végez iterációt. A lista elemei az általunk használt legtöbb eseteben karakterláncok. Használata: for i in lista 9

10 ne A -ban a i változó használható, és sorra felveszi a lista elemeinek értékét. A lista opcionális: amennyiben elhagyjuk, tehát használata így alakul: for i ne a i változó a parancssor paraméterein iterál, tehát változóban található sztringeket járja végig. Megadunk néhány példát: Egy általunk megatt lista végigjárása (for.sh): for i in abc def ghi echo i ne sorban az abc, def, ghi karakterláncokat fogja kiírni. Futtatásnál ezt látjuk: bash for.sh abc def ghi Ha pl. számokat akarunk végigjárni, akkor azokat a UNIX seq parancsával generálhatunk (for2.sh): for i in (seq 5) echo i ne bash for2.sh Látható, hogy ezúttal a listát parancssor behelyettesítéssel generáltuk a ( ) szerkezettel. A seq parancs kiír egy számokból álló szekvenciát, a korlátokat és a lépésközt az argumentumokban lehet megadni. Az implicit lépés az. Pl. a seq 2 0 hívás -től 0-ig írja ki a számokat, de csak minden másodikat. Egy könyvtárban található állományneveket pedig az alábbi ciklussal járjuk végig (for3.sh): 0

11 for f in ( ls ) echo f ne bash for3.sh.txt 2.txt megjegyzés: a bash itt a ls parancsot és nem az ls aliast hívja meg, ezért a visszaatt listába nem kerülnek színes kijelzést vezérlő karakterek, ami zavaró lenne. 6. A while és until ciklusok A while illetve until ciklusok feltételét ugyanúgy állítjuk elő, mint az if szerkezetét. A while addig folytatja a ciklust míg feltétele igaz értékkel lép ki, az until pedig amíg a feltétel hamis. Használatuk: és while feltétel_... ne until feltétel_... ne A while ciklust sokkal gyakrabban használjuk. Az alábbi példában addig olvasunk a terminálról, amíg az "end" szót gépeljük be. A példában a shell read parancsát használjuk: pontos használatát lásd a fejezet végén. line="" end="end" #addig olvas sorokat a terminalrol, amig begepeljuk #az abc sztringet while [ "line"!= "end" ] read line ne A while ciklust úgy kell tekinteni, mint egyetlen összefüggő parancssori elemet a kimenet és

12 bemenet szempontjából. Így csővezetéket irányíthatunk bele illetve állományt irányíthatunk a bemenetére. Az alábbi két példa végigolvassa egy állomány sorait, az első egy csővezetéken keresztül kapja a bemenetet: cat '.txt' while read line echo line #fellgozas itt ne Megjegyzés: a fenti példa esetében, amikor a while ciklusba csővezetéket irányítunk, a szerkezet parancsai új shell-ben (új folyamatban - lásd folyamatok c. fejezet - úgynevezett subshell-ben) hajtódnak végre. Így azok a változók, amelyeket a while belsejében hozunk létre, nem fognak látszani az indító shell-ből. Ez csak bizonyos shell-ekben van így, például a bash-ben. Pl. az alábbi szkriptben nem tudjuk a ciklus után kiírni az a változót: cat.txt while true a=2 break ne echo a Az alábbi while-ba pedig állományból irányítjuk a bemenetet: while read line echo line ne < '.txt' #fellgozas itt Az until ciklus akkor hasznos, ha valamilyen eseményt kell gyelni, és van egy változóm amelyik a ciklus végrehajtása közben, valamilyen esemény hatására kap értéket. Ennek ellenére, nagyon ritkán használjuk. # #az until szerkezet ciklus negativ logikaval #a teszt azt gyeli, hogy mekkora a line változó hossza #az első ciklusban meg nem is létezik until [ line ] echo 'A line valtozo erteke: ' "line" echo "Usse be pontosan az \"abc\" sztringet" read line #ha nem abc-t utott be, akkor torlom a valtozot #a shell unset parancsaval if [ "line"!= "abc" ]; 2

13 ne unset line A shell unset parancsa törli a megatt változót. Megjegyzés: A megfelelő ciklus szerkezet kiválasztása a héjprogramozásban nem annyira kötött, mint a strukturált programozásban, ahol a kiértékelt feltételtől függően illik tudni, hogy melyiket kell választani. Itt lazább lehet az ember, és azt választja amelyik jobban tetszik. 7. A break és continue használata A két shell utasítás hasonlóan működik a C-ből megszokott ciklus elhagyás utasításokkal. A break megszakítja a ciklust ott ahol megjelenik (és a ciklus utáni parancson folytatja), a continue nem fejezi be a kurrens ciklust hanem a következő iterációra lép. Megjegyzendő, hogy a break használható többszintű ciklusból való teljes kilépésre, pl. a break 2 elhagy egy 2 szintes ciklust. Az alábbi példában a break egy feltétel hatására elhagy egy végtelen ciklust. A végtelen ciklust a shell true parancsával vezéreljük, amelyik mindig igazat térit vissza (létezik az ellenkezője is, a false parancs, amelyik hamisat térít vissza a? -be). A read parancs -p kapcsolója egy készenléti jelet megadó karakterláncot ír ki. #vegtelen ciklus while true read -p "Írjon be egy sort:" line #ha nem üres a beolvasott sor kilepek a ciklusbol if [ -n "line" ] break ne 8. A shift parancs A shift "eltolja" a parancssor argumentumait egy argumentummal balra. Ugyanakkor a # változó értéke is változik, egyel csökken. Az alábbi példában a szkript kiír minden parancssori argumentumot, de úgy, hogy mindig a változót írja ki. A shift pedig minden ciklusban a átnevezi a,...,9 speciális változókat, úgy hogy a megfelelő parancssori értékeknek egyel kisebb számjegy nevű változót rendel. while [ # -gt 0 ] #amíg van még argumentum echo A '#' értéke: #, a '' értéke: shift ne 3

14 a végrehajtáskor ezt látjuk: Operációs rendszerek I. - UNIX felhasználói ismeretek és héjprogramozás./shift.sh a b c d A # értéke: 4, a értéke: a A # értéke: 3, a értéke: b A # értéke: 2, a értéke: c A # értéke:, a értéke: d A shift -et paraméterrel is meg lehet hívni, olyankor a paraméternek megfelelő számmal forgatja el a parancssor argumentumait, tehát a shift 2 hívás kettővel. 9. Kilépés a shell programból: az exit A shell programokból az exit paranccsal lépünk ki, melynek egy egész számból álló paramétere van, ez lesz a szkript visszatérítési értéke. Ha jól, hiba nélkül fut le a programunk, ez az érték 0 kell legyen. Az alábbi példa leteszteli, hogy a programunknak van-e legalább egy paramétere. Ha nincs, hibával lép ki. #tesztelem, hogy a parancssor első paraméterének 0 -e a hossza if [ -z "" ] echo legalább egy paraméter szükséges! exit # fellgozás itt exit 0 Ha elfelejtjük a program végéről az exit -et, az utolsó végrehajtott parancs által visszatérített érték marad a? változóban. 0. A read parancs A read parancs beolvas egy sort a parancssorról egy változóba vagy változó listába. Ha egy változót adunk meg a parancssorán, akkor a teljes sort abba olvassa, ha többet akkor a sort feldarabolja a shell implicit elválasztói szerint (szóköz és tabulátor) és a változók felveszik a szavak értékeit. read line tehát az egész sort a line-ba téríti vissza, read szo szo2 szo3 pedig a beütött szavakat a szo, szo2 stb. -be írja. fontosabb kapcsolói: -p prompt kiír egy készenléti jel karakterláncot olvasás előtt 4

15 -s silent: nem használ visszhangot, tehát nem látjuk a leütött betűket: jelszó beolvasásra jó -t timeout vár timeout másodpercig, ha az alatt nem ütünk be semmit, visszatér -n nchar csak nchar darab karaktert olvas, utána visszatér -d kar delimiter: más elválasztót keres a sorok végén mint az újsor karaktert A read igaz értékkel tér vissza a 0 -ban ha sikerült beolvasnia. Fájl vége (^D) esetén hamissal tér vissza, így lehet egy hosszabb beolvasási sorozatot leállítani. Az alábbi read kiír egy rövid szöveget, és siker esetén a sort visszatéríti a line változóba: read -p "Írd be a neved:" line Írd be a neved: Az alábbi csak 3 másodpercig vár, és csak egy karaktert olvas be az igen_nem változóba, utána visszatér: read -p "Igen vagy nem [I/N]?:" -n -t 3 igen_nem Igen vagy nem [I/N]?: Megjegyzés: a read -el egyelőre csak a standard bemenetről fogunk olvasni, ez az implicit működési módja. A parancs tud bármilyen állományból olvasni, ha megadjuk az állomány azonosítóját. Ezt a -u kapcsolóval lehet elérni. Az állományt ezt megelőzően az exec paranccsal meg kell nyitni és használat után le kell zárni egy bemenet lezáró operátorral. Ennek módjára adunk most egy példát, de mi nem fogjuk így használni a read-et. exec 6< ".txt" #állomány megnyitása 6-os azonosítóval read -u 6 line #egy sor beolvasása echo line exec 6<&- #állomány lezárása 5