Shell vagy héjprogramozás

Ez a tananyag a UNIX alapú operációs rendszerek egyik fontos komponensének, a shellnek vagy héjnak az alapszintű használatát mutatja be.

Nem célunk a UNIX alapú rendszerek meglehetősen bonyolult történetét bemutatni, azonban néhány részletet meg kell említenünk, hogy utaljunk a héjak jelenlegi használati lehetőségeire.

A UNIX operációs rendszert az AT&T, távközlésben működő cég Bell nevű laboratóriumában kezdték tervezni, 1969-1972 között, tervezői Ken Thompson, Dennis Ritchie, Doug McIlroy voltak (UNIX1970). A cél többfelhasználós multitaszking rendszer fejlesztése volt, amelyik valós idejű funkcionalitásokkal is rendelkezik.

Ezzel egy időben alakul ki a C nyelv standard könyvtára, és a klasszikus operációs rendszer függvények sora, így kialakulása összefonódik a C nyelv tervezésével (Dennis Ritchie és Brian Kernighan). A UNIX az első operációs rendszer amelynek kódja igen kis résztől eltekintve C-ben íródott. Első változatát PDP számítógépeken fejlesztették, ekkor alakult ki a klasszikus fájlrendszer struktúrája.

Az 1970-80-as évek jelentették a UNIX felhasználásának kezdeti időszakát. Mivel az AT&T nem forgalmazta a rendszert mint operációs rendszert önállóan, tervezési elvei és forráskódja sok fejlesztő laborba eljutott, elsősorban egyetemekre. Így több helyen is folytattak kiegészítő tervezői-fejlesztői tevékenységet. Több fontos fejlesztési vonulat alakult ki, ezek közül a legfontosabbak a System V illetve a Berkeley-i fejlesztésekre épülő BSD rendszerek. A UNIX szerzői joga átkerült más cégekhez, és egy meglehetősen bonyolult történetté alakult.

Jelenleg sok cég fejleszt saját UNIX-ot amelyek licencelt fejlesztések és az eredeti UNIX kódra épülnek: IBM, Hewlett-Packard, SCO, Novell, Oracle (a Sun Microsystems fejlesztését vette meg). Ezek vállalati kiszolgálók piacára fejlesztett rendszerek. Az Internet, telefonhálózatok stb. sok vonatkozásban UNIX-okon épültek ki, így ezek mai fejlettségéhez a UNIX-on használt elvek lényegesen hozzájárultak. A UNIX használatának egyik nagy előnyét kiváló hálózati és valós idejű szolgáltatásai jelentik.

A sok UNIX változat következményeként több standardizálási folyamat alakult ki (1984, X/Open Portability Guide: X/Open Company; 1988-2004, POSIX (Portable Operating System Interface): IEEE 1003-asnak is nevezett standard; 1995, Open Group: Single UNIX Specification). Ezek a standardok a UNIX programozási interfészeire illetve parancsnyelvére határoznak meg közös irányonalakat. A UNIX nevet, amely védett név (tulajdonosa jelenleg az Open Group nevű konzorcium) általában azokra a rendszerekre alkalmazzuk, amelyek követik az eredeti UNIX rendszerek felépítését, és meg is felelnek bizonyos szabványoknak (mint az Open Group Single UNIX Specification szabványa).

Unix alapú vagy Unix-szerű rendszereknek nevezzük azokat az operációs rendszereket, amelyek úgy viselkednek mintha UNIX rendszerek lennének. Ez az elnevezés vitatható, de célunknak megfelel. Ezek a rendszerek nem valósítják meg szükségszerűen minden vonatkozásban a UNIX standardokat. Ide tartozik több nyílt forráskódú operációs rendszer is, mint a Linux kernelre épülő rendszerek vagy a Free BSD. Ezek a rendszerek a 90-es években lettek népszerűek meg különböző nyílt forráskódú fejlesztések eredményeként.

A Linux egy UNIX-hoz hasonlóan viselkedő rendszer ("Unix-like", Unix-szerű rendszer, vagy klón): egész pontosan csak a rendszermag, a kernel klónja. A klón fogalma azt jelenti, hogy nem tartalmaz UNIX kódot, de más szoftver megoldásokat használva megvalósítja ugyanazt, mint egy eredeti UNIX kernel és hasonlóan is használható. Eredeti alkotója Linus Torvalds.

A Linux kernel köré fel lehet építeni egy operációs rendszert, ami Unix-szerűen viselkedik, ha a UNIX-hoz hasonlóan klón felhasználói programokkal vesszük körül. Egy ilyen összeállítást, ahol jelen van a Linux kernel és egy csomag felhasználói illetve rendszer program, Linux disztribúciónak nevezzük.

A shell vagy héj tulajdonképpen egy parancsértelmező, a felhasználó által parancssori szöveggel leírt parancsokat hajtja végre, így interfészt biztosít a felhasználó és az operációs rendszer között. Ebben az értelemben parancsnak nevezünk bármilyen futtatható programot amelyik része egy Unix alapú operációs rendszernek.

Az első időkben a héj (1970-es évek) egyszerűbb parancs nyelvet biztosított az akkoriban kialakuló UNIX rendszerek számára. Az évek haladásával ez a nyelv egyre bonyolultabb lett, több változata alakult ki, ezek saját fejlődési útjaikat járták, ettől kezdve már programozási nyelvi lehetőségeket is biztosítottak, ezért talán megengedhető az is, hogy a héjat programozási nyelvnek is nevezzük.

A UNIX parancsértelmező angol neve shell, a magyar nyelvű dokumentumokban ez helyenként burok, helyenként héj megnevezéssel fordul elő, a mindennapi nyelvben tapasztalatunk szerint gyakrabban használjuk magyarul is a shell megnevezést. Így ebben a tananyagban a héj és shell megnevezés egyaránt előfordul. A parancsértelmező neve arra utal, hogy burokként veszi körül a UNIX operációs rendszer legfontosabb komponensét, a rendszer magját vagy kernelt, és ennek szolgáltatásaihoz csak a parancsértelmezőn keresztül lehet hozzáférni, amikor egy felhasználó használni akarja a rendszert.

A Unix alapú rendszerek történelmi fejlődése folyamán több héjat terveztek, a legtöbb esetben megtartva az eredeti rendszerben használt héj elveit és kiegészítették különböző, a programozást könnyítő szerkezetekkel.

A Bourne shell volt az első parancsértelmező amelyiket kimondottan arra fejlesztették, hogy szkript nyelv is legyen egyben. 1977-ben kezdték fejleszteni az AT&T-nél (első fejlesztő Stephen Bourne). Ezzel vezettek be sok új lehetőséget először, mint a parancssor helyettesítés. A későbbi években is az AT&T-nél fejlesztették. Jelenlegi Linux disztribúciókon sh program név alatt található meg, és legtöbbször nem külön programként, hanem szimbólikus linkként, amely a rendszeren található Bash-re mutat (ez emulálja a Bourne shellt).

A héjak történetében egyik erős hatást kifejtő fejlesztés A Korn héj. Ezt a változatot ugyancsak az AT&T-nél fejlesztették (David Korn), és a legfontosabb fejlesztési cél a shell programozási nyelvvé való átalakítása volt. Visszafelé kompatibilis maradt a Bourne héjjal. Sok új lehetőséget vezettek be, így az asszociatív tömböket, az egész és valós számokkal való új számítási szerkezeteket. A POSIX standard "Shell Language Standard" nevű előírásait pontosan betartja, ezért gyakran ezt használják ipari standard héjként a UNIX variánsokban. Eleinte az AT&T tulajdonában volt a fejlesztése, 2000-ben nyílt forráskódúvá tették és jelenleg Common Public Licence licenc alatt fejlesztik (lásd http://www.kornshell.com/). Annak ellenére, hogy a mindennapi munkában sokan ennek modernebb változatait vagy a Bash-t használjuk, UNIX karbantartó vagy installáló szkriptekben legtöbben ma is a Bourne vagy a Korn változatait futtatják.

A C héjat (C shell) a Berkeley rendszerek fejlesztés során fejlesztették ki (fejlesztője Bill Joy, a későbbi Sun Microsystems alapító). Amint nevéből kiderül, szerkezetei hasonlítanak a C-re. Ebben fejlesztették tovább a feladatok (jobs) felügyeletét biztosító szerkezeteket. Nem annyira használt mint a Bourne-ra épülő változatok. Jelenleg tcsh nevű modern változatát használják, és leginkább a BSD alapú rendszerekkel.

A Bash (Bourne Again Shell) változatot eleve nyílt forráskódúnak kezdték fejleszteni, a cél a GNU operációs rendszer héjának fejlesztése volt, így lett a Linux kernelt használó rendszerek alapértelmezett héja. A kompatibilitás szempontjából Bourne és Korn héjat követi, és a legtöbb ezekre írt szkript lefut módosítás nélkül a Bash-en is. Mindhárom előzőleg említett shell-ből vett át megoldásokat, de fejlesztettek sok saját nyelvi lehetőségeket is. A Bash első fejlesztője Brian Fox volt, jelenlegi karbantartója és fejlesztője Chet Ramey.

Modern Linux-okon általában ez az alapértelmezett shell, és a leggazdagabb programozási lehetőségeket is ez nyújtja.

A felsoroltakon kívül több más fejlesztés is létezik, mint pl. az igen népszerű Z-Shell.

A héjak közti különbségek tárgyalása meghaladja ennek a tananyagnak a kereteit. Így feltételezzük, hogy a diák valamilyen Linux disztribúcióval dolgozik, és a Bash héj legalább 3.0 verzióját használja. A tananyagban nagyon kis kivétellel klasszikus szerkezeteket mutatunk be, amelyek az említett három héjból származnak és működnek a Bash-ben.

A standard UNIX rendszereken és a Linuxon kívül más Unix alapú operációs rendszerek esetében is használható a Bash, mint a BSD rendszereken vagy az Apple gépeken futó OS X alatt (Darwin).

Windows rendszereken is használható, amennyiben telepítjük a Cygwin eszközöket (http://www.cygwin.com), bár kezdeti tanuláshoz nem ajánljuk ezt, mert ilyen környezetben különbségek adódnak a használatában.

A héj legfontosabb feladatai: Unix parancsok indítása, összefűzése, felügyelete. Így a tananyag részben a fontosabb Unix parancsok bemutatásával is foglalkozik. Mivel nem tehetjük meg ezt kimerítően, a parancsok leggyakoribb használati módját és opcióit mutatjuk be. Ezek kimerítő tanulmányozásához a parancsok kézikönyv (vagy man) lapjaihoz, esetenként info lapjaihoz kell fordulni.

A parancsok használatának esetében is feltételezzük a Linux disztribúciók használatát. UNIX illetve más Unix szerű rendszerek felhasználói esetenként más vagy másként használható opciókkal találkozhatnak a saját rendszereiken.

A héj használata számtalan irányba ágazik, a tananyag ebben a vonatkozásban a leggyakrabban használt sémákat mutatja be. További és folyamatos tanuláshoz a Bibliográfiában említett könyveket, illetve Interneten a Bash Reference Manual (BashRef2010) és Advanced Bash-Scripting Guide (Mendel2011) munkákat, valamint magyar nyelven Büki András: UNIX/Linux héjprogramozás című könyvét (Buki2002) ajánljuk.

A tananyag folyamatosan vezeti be a héj szerkezeteit.

A második fejezet a Unix terminál használatához ad néhány támpontot, a héjhoz kötődő fogalmaink itt még nem egészen pontosak, a fejezet célja bevezetni az olvasót a Unix parancsok gyakorlati használatához szükséges részletekbe.

A harmadik fejezet a Unix fájlrendszeréhez kötődő fontosabb fogalmakat és gyakran használt fájlkezelő parancsokat ismerteti.

A negyedik fejezet a Unix parancssor kezelés és parancs végrehajtás fogalmaiba nyújt bevezetőt.

Az ötödik fejezetben a héj változóival és azok egyszerű használatával foglalkozunk.

A hatodik fejezet a héj vezérlő szerkezeteit tárgyalja.

Mivel a reguláris kifejezések sok Unix parancs alapvető használatában jelen vannak, a hetedik fejezetet ennek a kérdéskörnek szánjuk.

A nyolcadik fejezetben további szerkezeteket mutatunk be, amelyek nem egy bizonyos témakörbe illeszkednek, de igen hasznosak a héj használata folyamán. Így ez a fejezet vegyes tematikájú.

A kilencedik és tizedik fejezet a Unix két ismert és gyakran használt parancsának, a sed-nek és awk-nak ismertetésére szánjuk.

A tizenegyedik fejezetben a Unix folyamatok kezelésével foglalkozunk

A tananyagot első illetve másod éves műszaki informatika vagy informatika szakos hallgatóknak szánjuk, egy bevezető UNIX/Linux tananyag egyik részeként, így feltételezzük, hogy az olvasó ismeri például a C nyelvet. Ettől függetlenül használható az anyag más kontextusban is.

Jelenleg bármely Unix vagy Linux rendszer grafikus, ablakkezelő interfésszel is rendelkezik, ha egy személyi számítógépen vagy munkaállomáson használjuk. A legtöbb PC-re telepített Linux rendszer ezzel indul el. Az ablakkezelő rendszerben viszonylag könnyű eligazodni - már ami a programok egyszerű elindítását illeti. A héjhoz kötődő munkát viszont általában egyszerű szöveggel leírt parancsokkal végezzük, ezeket pedig parancssoron gépeljük be. Így elegendő egy jóval egyszerűbb interfészt használni mint a grafikusat. Amennyiben grafikus interfész van előttünk, akkor ennek az interfésznek az elérésére egy kis programot indítunk el, amely általában egy terminál emuláló program. A program egyszerű beviteli eszközt utánoz, amelybe csak szövegsorokat lehet begépelni, illetve válaszként szövegsorokat ír ki. Ez a parancs beviteli mód a UNIX rendszerek használatának történelméhez kötődik, de ma is aktuális és hatékony.

A 70-es évek UNIX-ához ember-gép interfészként egy külső hardver eszköz csatlakozott, amelyet teletype-nek neveztek (ez távirati rendszerekben használt terminál utóda volt, így lett a rendszerben a terminált csatlakoztató speciális fájlok neve tty). A kommunikáció egy soros kommunikációs vonalon keresztül zajlott, a bemenet írógépszerű billentyűzet volt, a gép által visszaírt szöveget papírra nyomtatta (ezért zajlott a kommunikáció mindkét irányban szövegsorokon keresztül). Később (1978 körül) képernyős terminálok jelentek meg (CRT - Cathode Ray Tube terminálok). Legismertebbek a DEC cég VT sorozata, pl. a VT100. Ezeken a kurzort mozgatni lehetett, ezt a kiíró szoftver vezérlő, un. escape szekvenciákkal tette. Az első időszakban ezek nem tudtak grafikus képet megjeleníteni. A szöveget 80 oszlop, 23 vagy 25 sor méretben tudták kiírni. Utánuk a grafikus terminálok következtek, ezek egy programot futtattak (X server) amely a UNIX-ot futtató gép grafikus alkalmazásai jelenítette meg. Ezek voltak az X terminálok.

Később személyi számítógépeken a hagyományos terminált egy program jelenítette meg a grafikus képernyőn, bemeneti eszközként a gép billentyűzetét, kimenetként pedig a képernyőt használták. Ezek a rendszerhez egy programon keresztül csatlakoztak, ugyanis itt már nem volt szükség egy külső hardver kapcsolatra. Például a UNIX rendszerekben használt X Window grafikus felület esetében ez a program (X terminál) kirajzolt egy terminált, ami úgy nézett ki, mint egy terminál képernyő. A géptől jövő információ (karakterek és kurzorvezérlés továbbra is úgy érkezett mint a CRT termináloknál, de a szoftver átalakította grafikus képpé). Mivel a program pont úgy viselkedett, mint pl. egy igazi VT-100 terminál, azt mondjuk, hogy a szoftver a VT-100 terminált emulálta.

Így pl. a PC-k esetében a parancssor beütése ugyanúgy történik, mintha egy külső eszközt használnánk terminálként. A terminált emuláló programnak ezúttal nem volt szüksége egy konkrét hardware eszközre (pl. a soros port), hanem az operációs rendszer nyitott a számára 2 fájlt (pontosabban karakter eszközt) amin keresztül a kommunikáció zajlott. Ezért ezt az eszközt pseudo terminálnak nevezik.

A terminál billentyűjén beütött karakterek eljutnak egy programhoz, az pedig a karakterekre adott választ visszaírja a terminál képernyőjére. A programmal való kapcsolat két irányú, ezt full duplex működési módnak nevezzük. Ha a billentyűn leütött karaktert a vezérelt program fogadta, visszaírja a terminál képernyőjére – ekkor az megjelenik, ezt nevezzük visszhangnak (echo).

Az alábbi képernyőkimenet parancs beviteleket és a rendszer által kiírt válaszokat tartalmaz:

$ ls
a.out  echoarg.c  echo.c
$ ls -l -t
total 16
-rwxrwxr-x 1 lszabo lszabo 4847 Feb  7 10:44 a.out
-rw-rw-r-- 1 lszabo lszabo  198 Feb  7 10:43 echoarg.c
-rw-rw-r-- 1 lszabo lszabo  232 Feb  7 10:43 echo.c
$ ls -l echo.c
-rw-rw-r-- 1 lszabo lszabo  232 Feb  7 10:43 echo.c
$ 

A kimeneten a $ karakter és az utána következő szóköz a héj készenléti jele (prompt), az ls a begépelt parancs (ez fájlok nevét és tulajdonságát listázza), amelyet egymás után háromszor hívunk meg: első alkalommal opciók nélkül, második alkalommal a -l és -t opcióval (ami részletes listát és módosítás szerinti lista sorrendet kér,a harmadik alkalommal csak az echo.c nevű programot listázzuk részletesen. Látható, hogy a héjjal való kommunikáció folyamatos gépelést jelent, ezért maga a Unix terminál kezelő alrendszere, illetve a használt programok is biztosítanak olyan szerkesztési műveleteket amelyek felgyorsítják ezeknek a soroknak a gyors gépelését. Ezek a műveletek általában kontroll karakterekhez vannak rendelve.

	Készenléti jel vagy prompt
	A könyv terminál ablak példáiban készenléti jelként a $ jelet és az utána következő szóközt fogjuk használni, amely csak akkor vehető észre ha van valami a parancsoron, üres parancssoron nem látható: $ Esetenként ez a különböző rendszereken más és más karaktersor lehet, általában egy praktikusabb üzenet, például a munkakönyvtár neve. Ezzel kapcsolatban lásd a PS1 környezeti változót.

A terminál beállításait az stty paranccsal lehet megnézni illetve módosítani. Pl. a -a opciója kilistázza a terminál beállításait, ennek a kontroll billentyűkre vonatkozó része így néz ki:

$ stty -a
speed 38400 baud; rows 38; columns 80; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>;
eol2 = <undef>; swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; 
rprnt = ^R;werase = ^W; lnext = ^V; flush = ^O; min = 1; time = 0;
$ 

Az alábbiakban a kontroll és valamilyen más billentyű, pl. a C egyidejű lenyomását Ctrl-C -vel, illetve az Alt és C egyidejű lenyomását Alt-C -vel fogjuk jelölni.

A paraméterek terminál jellemzőket tartalmaznak, témánk szempontjából az első néhány sor tartalmazza azokat a kontroll karakter - terminál művelet hozzárendeléseket, amelyek a kernel terminál alrendszere kezel. Például a Ctrl-C karakterre a terminál az intr (interrupt) műveletet hajtja végre, azaz megszakítja a terminálon elindított, futó programot (pontosabban jelzést küld, lásd a Jelzések című alfejezetet). Az alábbi táblázat tartalmazza a fontosabb műveleteket:

Az stty segítségével ezek a hozzárendelések módosíthatóak, pl.:

$ stty intr Ctrl-X

megváltoztatja a megszakító kombinációt, Ctrl-C helyett Ctrl-X-re.

A fenti kombinációk minimális szerkesztési lehetőséget jelentenek, ezért a futó programok ennél jobb szerkesztési lehetőségeket építhetnek be a parancssor kezelésébe. A Bash héj a GNU Readline nevű sor szerkesztést biztosító könyvtárát használja, ez elegáns szerkesztési opciókat biztosít.

Az alábbi táblázat a legfontosabbakat tartalmazza a szerkesztési parancsok közül.

Amennyiben a terminálra hosszabb szöveget írunk és az kifut a rendelkezésre álló sorokból, az alábbi parancsokkal forgathatjuk illetve törölhetjük a szöveget:

A szerkesztési opciókon kívül, a gépelés felgyorsítható, ha a parancssort fogadó program rendelkezik szavakat kiegészítő opcióval (word completion). Szavakon a parancsnyelv esetében karakterek sorozatát fogjuk érteni. Ez azt jelenti, hogy a begépelt szavak kezdőbetűi után a Readline felismeri, hogy mit akarunk beírni, és kiegészítheti a szavakat. A Readline a parancsneveket, fájlneveket és változó neveket is képes kiegészíteni. Az időtrabló általában a fájlnevek beírása, próbálkozzunk először ennek gyakorlásával. A szavak kiegészítésére a tabulátor karaktert használjuk (Tab billentyű).

Ha a fájlnév első betűje (pl. legyen ez a) után egy tabulátor karaktert ütünk le , akkor a Readline kiegészíti automatikusan a fájl nevét - amennyiben egy olyan fájl vagy könyvtár van a munka könyvtárban amely a betűvel kezdődik.

Ha nincs ilyen fájl, a terminál egy csipogó hangot hallat (legelábbis általában így van beállítva, de természetesen a csipogás kikapcsolható).

Ha több ilyen fájl van, akkor ismét csipog, ilyenkor egy második tabulátor leütésével ki lehet íratni ezeket a fájlneveket, és folytatni lehet a parancssort a fájl második, harmadik, stb. betűjével, addig amíg a sorozat egyedi lesz: utána ismét leütve a Tab billentyűt kiegészül a név. A Tab leütésekor, amennyiben karakter egyezés van a nevek elején, a kiegészítés a parancssoron megtörténik addig a karaktermintáig amely közös a nevek első részében.

Ugyanez alkalmazható a parancsok nevére illetve héj változók nevére is (a szavak parancssori helyének kontextusától függően fogja ezeket kiegészíteni).

Pl. amennyiben az alábbi parancsot akarjuk leírni, és az előző példában használt két fájl van a könyvtárban (echoarg.c és echo.c):

$ gcc echoarg.c

A fenti példában nem volt látványos a nyereség, de vannak 30-40 karakteres fájlneveink, amikor szinte lehetetlen a kiegészítő opció nélkül dolgozni.

$ ls 2.txt
2.txt
$ ls 1.txt
1.txt
(reverse-i-search)`2': ls 2.txt

A bejelentkezés egy asztali PC-n található rendszer esetében, amelyen el van indítva a grafikus felhasználói környezet egy grafikus ablak által megvalósított név/jelszó űrlap kitöltéséből áll. Amennyiben a felhasználót azonosítja a rendszer, elindítja mindazokat a szolgáltatásokat amelyre a felhasználónak szüksége van, többek közt a grafikus felületet. Linux rendszereken a leggyakoribb a Gnome vagy KDE (K Desktop Environment) elnevezésű grafikus felület.

Amennyiben a gépen nincs elindítva grafikus környezet, akkor a felhasználói interfész gyakorlatilag egy egyszerű szöveges terminál interfész. Asztali Linux rendszeren könnyen előhívhatunk egy ilyent, még akkor is ha a rendszer elindítja a grafikus interfészt. A Ctrl-Alt-F1, Ctrl-Alt-F2, ...,Ctrl-Alt-F6 billentyű kombinációk hatására egy virtuális terminált hív meg a rendszer, a gép billentyűzetet és és képernyőjét használva szöveges módban. Linuxon ezt a rendszerben elindított mingetty nevű folyamatok biztosítják, amelyek indításkor automatikusan indulnak (a grafikus felületet futtató terminálhoz általában a Ctrl-Alt-F7 kombinációval jutunk vissza).

A bejelentkezés ebben az esetben is név/jelszó pár, és ami ilyenkor történik az a klasszikus Unix belépés a rendszerbe (ugyanezt fogjuk tapasztalni, ha egy már megnyitott terminálról belépünk hálózaton keresztül egy távoli gépre). Linux rendszeren a felhasználó nevet átvevő mingetty folyamat egy login nevű programot indít el: ez bekéri a jelszót. Ha sikerült azonosítania a felhasználót elindítja a héjat, ezt a példányt login shell-nek nevezzük. A héjnak parancsokat írhatunk be, majd ha munkánkat befejeztük akkor a logout vagy exit parancsokkal léphetünk ki.

A belépés után a rendszer elindítja számunkra a héjat, amelyik a következőket végzi:

Egy parancs szintaxisa a Unix rendszereknél:

parancsnév [opciók] [argumentumok]

A parancs név valamilyen futtatható fájl neve, az opciók (vagy más néven kapcsolók, switch-ek) egy adott parancs lefutási módját befolyásolják. Az opciók és argumentumok is lehetnek "opcionálisak": nem kell feltétlenül megadni őket ahhoz, hogy végre tudjuk hajtani a parancsot. Ezt jelzi a [] zárójel a parancsok szintaxisában. Opciót kétféleképpen adhatunk meg, rövid (egy - jel az opció előtt, ilyenkor az opciót egy karakter jelöli) illetve hosszú formában (két - jel az opció előtt, az opció egy szó). Az első esetben a kapcsoló általában egy karakter, a másodikban egy egész szó. Az ls esetében a -l opció részletes listát kér, a --color pedig a színes listázást tiltja le:

$ ls -l
total 16
-rwxrwxr-x 1 lszabo lszabo 4847 Feb  7 16:34 a.out
-rw-rw-r-- 1 lszabo lszabo  198 Feb  7 10:43 echoarg.c
-rw-rw-r-- 1 lszabo lszabo  232 Feb  7 10:43 echo.c
$ ls --color=no
a.out  echoarg.c  echo.c
$ 

Több opciót megadhatunk csoportosítva is:

$ ls -1tr
echo.c
echoarg.c
a.out
$ 

A parancs nevekben, opciókban a kis-nagy betűk számítanak, a Unix parancsai általában kisbetűsek. Néhány példa az ls parancs használatára különböző kapcsolókkal (a # karakter a shell számára a megjegyzés kezdetét jelenti, a '$ ' pedig az alábbi esteben a shell késznléti jele.

$ #hosszú lista
$ ls -l
total 8
-rw-r--r-- 1 lszabo lszabo  0 Sep 19 14:26 1.txt
-rw-r--r-- 1 lszabo lszabo  8 Sep 19 14:26 2.txt
-rw-r--r-- 1 lszabo lszabo 54 Sep 19 14:27 3.txt
$ #időrendben listáz, legelől a legutóbb létrehozott fájl
$ ls -t
3.txt  2.txt  1.txt
$ #fordított sorrendben listáz
$ ls -rt
1.txt  2.txt  3.txt
$ #fordított sorrendben, időrendben és részletesen
$ ls -ltr  
-rw-r--r-- 1 lszabo lszabo  0 Sep 19 14:26 1.txt
-rw-r--r-- 1 lszabo lszabo  8 Sep 19 14:26 2.txt
-rw-r--r-- 1 lszabo lszabo 54 Sep 19 14:27 3.txt
$ #ezt így is be lehet ütni:
$ ls -l -t -r
-rw-r--r-- 1 lszabo lszabo  0 Sep 19 14:26 1.txt
-rw-r--r-- 1 lszabo lszabo  8 Sep 19 14:26 2.txt
-rw-r--r-- 1 lszabo lszabo 54 Sep 19 14:27 3.txt
$ #a file1 és file2 tulajdonságait listázza
$ ls -l 1.txt 2.txt
-rw-r--r-- 1 lszabo lszabo 0 Sep 19 14:26 1.txt
-rw-r--r-- 1 lszabo lszabo 8 Sep 19 14:26 2.txt
$ 

Ha egy parancs szövege túl hosszú a terminál parancssorán, az folytatható a következő sorban.

Példaként vegyük az echo parancsot, amelyik a parancssori argumentumait írja ki:

$ echo ez egy szöveg
ez egy szöveg
$

A szöveg folytatását egy második sorban meg lehet oldani úgy, hogy a szövegben idézőjelet nyitunk és leütjük a RETURN billentyűt, így az a következő sorban lesz folytatható. Ott zárhatjuk az idézőjelet, és egy újabb RETURN-el indíthatjuk a parancsot:

$ echo "ez egy hosszú szöveg első része
> ez pedig a második"
ez egy hosszú szöveg első része
ez pedig a második
$

Látható, hogy a $ helyett egy másik készenléti jel, a > jelenik meg ilyenkor.

Ennél fontosabb, a sorvégi vissza-per jel használata, amelyikkel bármilyen sort le lehet zárni, és folytatni a következőben (nem idézett szöveget):

$ echo ez egy hosszú szöveg első része \
> ez pedig a második
ez egy hosszú szöveg első része ez pedig a második
$

Látható a különbség is: az első esetben az újsor bekerül a parancssorba, a másodikban pedig nem, a módszer arra jó, hogy egyszerűen folytassuk a sort.

Ezt a megoldást héjprogramokban is alkalmazhatjuk, bármikor. Ennek az anyagnak a példáiban is többször alkalmazásra kerül azért, hogy a hosszú sor ne nyúljon túl az oldal szélességén. Természetesen munka közben a terminálnak lehet hosszabb sorokat is beírni mint az ablak szélessége.

Fontos: a sor végét lezáró \ után egyetlen karakter sem jöhet, csak az újsor.

Az állományok vagy fájlok névvel elérhető adathalmazok a számítógép tárolóin. Szervezésüket az operációs rendszer oldja meg, és a héjprogramozás számára az egyik fontos "adattípust" is jelentik. A héjprogramok egyik gyakori feladata a fájlok kezelése (fájlokat mozgatnak el, törölnek, keresnek, stb.), ezért a Unix rendszerek fájl szervezését ismerni fontos.

Aki tisztában van a Unix rendszerek fájlrendszerének struktúrájával és a leggyakrabban használt fájlkezelő parancsokkal, átlapozhatja a fejezetet.

A Unix egy általános fájl fogalommal dolgozik, amelyet egyszerű 8 bites karakter (byte) folyamnak tekint (byte stream). Az operációs rendszer szintjén nincs különösebb jelentése a fájlok tartalmának. A rendszer egyik szellemes megoldása, hogy nem csak a különböző adathordozókon található adatokat tekinti fájlnak, hanem a hardver eszközöket is. Ebben a fejezetben elsősorban a szabályos, adathordozókon található fájlokkal foglalkozunk.

A fájl nevek karakterekből állnak, hosszuk rendszerenként változik, de számíthatunk arra, hogy egy modern rendszeren akár 255 karakter hosszúak is lehetnek. Bármilyen karaktert tartalmazhatnak kivéve / és \0 (a C programozásban a sztring végi null) karaktereket. Ennek ellenére fájl nevekben nem ajánlatos speciális karaktereket használni, mert az ilyenek zavarhatják a feldolgozásukat. Az ajánlott karakterek a betűkön és számokon kívül a _ , - és a . . Kis és nagybetűk közti különbség számít, tehát a naplo.txt és Naplo.txt nevek nem ugyanarra a fájlra mutatnak.

A könyvtár (directory) is egy fájl, amely könyvtári bemeneteket tartalmaz. Ezek adják meg a könyvtár alá szervezett fájlok, illetve más könyvtárak listáját és elérhetőségét.

A Unix fájlrendszere hierarchikus, fa szerű struktúra, amely első megközelítésben két szerkezetből, a könyvtárakból illetve fájlokból épül fel (amint azt látni fogjuk, tulajdonképpen a könyvtárak is fájlok, és a tartalmazott fájlok több típusúak lehetnek). A könyvtárszerkezet egy gyökérnek nevezett könyvtárral indul amelynek a neve egy karakter, a per jel: / (a gyökér könyvtár angol neve: root directory).

A gyökér alatt az alábbiakat láthatjuk:

A Linux tree parancsa a fájlrendszer első szintjét így jeleníti meg (valamennyi megjelenő név könyvtár, az -L opció a listázott könyvtár szintet adja meg):

$ tree  -L 1 /
/
|-- bin
|-- boot
|-- data
|-- dev
|-- etc
|-- home
|-- lib
|-- lost+found
|-- mediac
|-- mnt
|-- proc
|-- root
|-- sbin
|-- selinux
|-- sys
|-- tmp
|-- usr
`-- var
$ 

Legfelül a gyökér könyvtár található, nyilván ez nem tartalmaz .. mutatót. Abban az esetben, ha mégis használná valaki, itt alapértelmezetten a .. is a / -re mutat, tehát: /../bin vagy /../../bin az ugyanazt a /bin-t jelöl.

A könyvtárrendszer első szintjét úgy határozták meg, hogy jellegzetességeik szerint csoportosították a fájlokat, így adódtak az általánosan használt első szintű könyvtárnevek. Így a felhasználó gyorsan megtalál bármilyen fájlt, mert nagy valószínűséggel tudja, melyik csoportban található. Ez a felosztás nem teljesen egyforma a különböző UNIX rendszerek illetve Linux disztribúciók esetében, de a felosztási elvek nagyjából ugyanazok (Az alábbi példák a Red Hat cég Fedora disztribúciójában találhatóak így).

A Unix rendszerek használata mindig felhasználói jogosultságokhoz kötődik. A felhasználók egy bejelentkezési nevet kapnak, a bejelentkezés a rendszerbe általában jelszóval történik. Amikor a rendszerrel dolgozunk, az alábbi felhasználóhoz kötődő helyek adottak a fájlrendszerben:

A programozásnál a fájlneveket kezelni a basename (egy abszolut elérési út fájlnevét írja ki) és a dirname (egy abszolut elérési út könyvtárnevét írja ki) segít:

$ basename /usr/include/readline/keymaps.h
keymaps.h
$ dirname /usr/include/readline/keymaps.h 
/usr/include/readline        

A fájl elnevezési konvenciók a UNIX alatt nem kötelezőek, bármilyen nevet és kiterjesztést adhatunk a különböző tartalmú fájloknak. Pl. bármilyen nevű vagy végződésű fájl lehet futtatható. Elnevezési konvenció azonban létezik, és többnyire használjuk is, hogy különbséget tegyünk a fájlok közt (gyakran használt végződések: .c, .o, .h, .txt, .gz, .ps, .tgz, .tar, .sh, .tex, stb.).

A UNIX könyvtárakat létrehozó parancsa a mkdir, könyvtárat törlő parancsa a rmdir. A könyvtár fa struktúrájában a munkakönyvtárat a cd paranccsal lehet váltani (rövid bemutatásukat lásd a fejezet végén).Egy egyszerű könyvtárstruktúrát a tree paranccsal írhatunk ki.

A közönséges fájlok többnyire mágneses lemezeken vagy más adathordozókon találhatóak. Megkülönböztetünk szöveges ("szemmel" is olvasható, text) illetve bináris fájlokat.

Információt a fájlokról az ls (listázás), file (típus kiíratás) és stat (fájl rendszer adatai) nyerünk.

A szöveges fájlok igen fontosak a Unix rendszerek alatt, a legtöbb program szöveges formában tartja konfigurációs adatait, valamennyi Unix parancs szövegeket ír ki a kimenetre és szövegeket olvas a bemeneten. A szöveges fájlok a használt karakterkészlet olvasható karaktereiből épülnek fel. A karakterek szövegsorokat alkotnak melyeknek végén egy újsor karakter található (ASCII kódja 10).

A fájlok lehetnek 0 byte hosszúak (üres file) is. Maximális hosszukat egy előjeles egész számmal tárolt fájlhossz korlátozza. Régebbi rendszereken ez 32 bites előjeles szám, így a maximális hossz kb. 2 GB. Modern rendszerek képesek a fájlhosszat 64 bites számban tárolni, ez elméletileg 8 milliárd Gigabyte-os fájlokat enged meg.

Minden felhasználónak (user) bejelentkezési neve van (login name) és egy csoporthoz (group) tartozik. A felhasználó jelszóval jelentkezik be. A felhasználók illetve csoportok neveit a rendszer a nyilvános password fájlban, illetve a csoportokat tartalmazó fájlokban tartja (/etc/passwd, /etc/group).

Modern rendszerekre való bejelentkezés történhet valamilyen hálózaton keresztüli azonosítással, amikor a felhasználót azonosító adatokat nem az a gép tárolja amelyre bejelentkezünk.

A rendszerben egyetlen felhasználónak van jogosultsága bármilyen műveletet elvégezni, ezt a felhasználót a Unix rendszerek root-nak nevezik (ő a rendszergazda vagy superuser). Az többi felhasználó jogai korlátozottak, és általában a tulajdonában álló objektumok (pl. fájlok) vonatkozásában korlátlanok (ezekkel bármit tehet), a más felhasználó tulajdonában álló objektumok vonatkozásában korlátozottak.

A felhasználókat a rendszer a felhasználó neve és jelszó szerint azonosítja, a rendszerben viszont egész számokkal tartja nyilván (user id vagy uid, group id vagy gid). A bejelentkezett felhasználó az id paranccsal listázhatja ezeket ki (illetve megtalálja őket a passwd fájlban):

$ id 
uid=500(lszabo) gid=500(lszabo) groups=500(lszabo) 
$ 
            

A fájlokat a felhasználó által futtatott programok hozzák létre. A Unix alapú rendszerekben kétféle tulajdonjog létezik a fájlokon: felhasználói (user) és csoport (group). Így minden fájl valamelyik felhasználó illetve valamelyik csoport tulajdona. Létrehozásnál egy új fájl mindig a felhasználó és annak csoportja tulajdonaként jön létre, egy implicit elérési joggal (lásd alább). Ezek a jogosultságok a chmod paranccsal változtathatóak, a fájlhoz rendelt (tulajdonos) felhasználó és csoport pedig a chown és chgrp parancsokkal.

A fájlok nevének és tulajdonságainak listázására az ls parancsot használjuk.

A chmod parancs négy csoportra osztja a felhasználókat az elérési jogok megállapítása kapcsán (a chmod parancs egy-egy betűt használ a csoportok megjelölésére):

A jogokat egy 3 jegyű oktál számmal ábrázolja a rendszer, mert 3 jog állítható be minden fájlon 3 kategória számára (user, group, others). Ezek a jogok, valamint betűjelük:

Tehát egy fájlon beállított, tulajdonos-csoport-mások számára beállított jog így néz ki, ha ezeket a szimbólumokat egymás mellé írjuk:

rwxr--r--

A három oktál szám ugo, mindegyiknek 3 bitje lehet: rwx, amennyiben egy bit nincs beállítva, helyette kötőjelet ír ki például az ls parancs. A fenti példa jelentése: a tulajdonos írhatja, olvashatja, végrehajthatja míg a csoport tagjai illetve mások csak olvashatják (oktálban a kombinációt így fejezzük ki: 744). Az alábbi jog kombináció esetében a tulajdonos bármit tehet az állománnyal, a többiek olvashatják és futtathatják de nem módosíthatják (oktál 755):

rwxr-xr-x

A könyvtárak tartalmazzák a fájlok neveit: a Unix rendszerek fizikai fájlszervezésében a fájl nevek nincsenek hozzákötve a fizikai tárolás leírását tartalmazó struktúrákhoz. Ezeket a struktúrákat általában egy azonosító egész számon keresztül érjük el, a strktúra neve i-node (a névnek történelmi gyökerei vannak, az első UNIX tervezéséhez kötődik). A könyvtárak valósítják meg a név és i-node-ok közti kapcsolatot, így ezek listákat tárolnak, melyben a név és i-node egymáshoz rendelések találhatóak.

A könyvtárak esetében az r jog jelentése a könyvtár fájl "olvasása": ez gyakorlatilag azt jelenti, hogy a benne levő név lista leolvasható és listázható (tehát nem a könyvtár tartalma, hanem a könyvtár fájl tartalmára vonatkozik az olvashatóság).

A w jog a könyvtár fájl "írhatóságát" jelenti: tehát a könyvtárban létrehozható új fájl, törölhetőek a meglevőek.

Az x végrehajtási jognak megfelelő bit viszont itt egészen mást jelent: a könyvtár "átjárható", azaz amennyiben egy felhasználó a fájlrendszer fastruktúrájában keres, keresheti az illető könyvtár alatti fájlokat, illetve könyvtárakat, és leolvashatja (írhatja) azokat amennyiben joga van rá. Ugyanakkor cd paranccsal beléphet az ilyen könyvtárakba, és haladhat lefelé a könyvtárstruktúrán.

Az x jog megvonása mindezen jogok elvesztését jelenti.

A root felhasználó mindent leolvashat illetve írhat a rendszerben, és azokat a fájlokat amelyeken legalább egy x bit be van állítva (bárkinek) végrehajthatja.

A hozzáférési jogok állítása a chmod, a tulajdonos beállítása a chown parancsokkal történik, listázásuk az ls parancs -l opciójával. A chown parancs végrehajtása közönséges felhasználó számára nem megengedett a setuid mechanizmus veszélyei miatt (lásd alább).

A chmod bemutatását lásd a fejezet végén, itt néhány példát adunk a használatára.

A 1.txt fájlra az rwxr--r-- jogot az alábbi parancs segítségével állítjuk:

$ chmod 744 1.txt                    
$ 

az oktál számok segítségével. Ha ezt módosítani akarjuk a rwxr-xr-- jogra (a csoportomnak végrehajtási jogot adok) akkor az alábbit tehetjük, ha szimbólumokkal akarjuk megadni a jogokat a chown parancsnak:

$ chmod g+x 1.txt                   
$ 

Az implicit jogokat amelyeket a rendszer akkor használ ha egy bizonyos felhasználó egy új fájlt hoz létre az umask paranccsal állítjuk be (lásd alább).

Az említett jogokon kívül egy negyedik oktál szám speciális információkat tartalmaz a jogosultsági bitek közt:

Oktálban a chmod parancs egy negyedik számjegyet használ a fenti bitek beállításakor, ennek értéke: 4: setuid, 2: setgid, 1:sticky bit. Például a /tmp könyvtár jogainak beállításakor az alábbi parancsot kellene kiadni ha betűkombinációt használunk:

$ chmod a+rwx /tmp
$ chmod +t /tmp                
$

és az alábbit ha oktál számot:

$ chmod  1777  /tmp        
$

Ezek után érthetőek az ls parancs által kiadott listák. Az rwx jogok kijelzése előtt van meg egy karakter, amely a file típusát jelzi. Reguláris file esetében egy kötőjel áll ott, más speciális esetekben az alábbi karakterek: d - könyvtár, l - szimbolikus link, b - blokk eszköz, c - karakter eszköz (lásd eszközök).

$ ls -l
total 4
drwx------ 2 lszabo lszabo 4096 Oct  3 19:36 piros        
-rw-rw-r-- 1 lszabo lszabo    0 Oct  3 19:35 1.txt
lrwxrwxrwx 1 lszabo lszabo    5 Oct  3 19:36 2.txt -> 1.txt
$ 

A GNU ls esetében a különböző típusú fájlokat más-más színnel színezi az ls ha interaktív módban használjuk.

Az újonnan létrehozott fájlok számára a héj kap a rendszertől egy beállítást, ami meghatározza milyen jogosultságokkal jön létre egy új fájl. A beállítást egy maszk tartalmazza, amelyet umask-nak neveznek, és információként azt tartalmazza, milyen jogosultságot ne állítson be a shell amikor létrehoz egy új fájlt. A maszk beállítása feltételezi, hogy a végrehajtási jogot amúgy sem kell implicit beállítani (ezt mindig tudatosan állítja be egy program ha szükséges), a többi jogra pedig egy 3 oktál számból álló maszkot ad meg. Ennek eredeti értéke 0002 vagy 0022 (a szám 4 jegyű, az rwx biteken kívül a kiegészítő biteket is tartalmazza). A 0002 jelentése a létrehozandó fájl ugo csoportjainak rwx bitjeire vonatkozik, és az egyetlen beállított bit azt jelenti, hogy egy újonnan létrehozott fájl nem lehet mások által írható (a 0022 esetében a csoport által sem).

Az implicit jogokat egy új fájl létrehozásakor az umask paranccsal állíthatjuk be. A parancs egy argumentumot fogad el, amivel átállíthatjuk a maszkot. Például az alábbi parancsok kiadása után:

$ umask 0002
$ touch test.txt
$ ls -l test.txt
-rw-rw-r-- 1 lszabo lszabo 0 Mar  3 15:28 test.txt
$ umask 0022
$ touch test1.txt
$ ls -l test1.txt
-rw-r--r-- 1 lszabo lszabo 0 Mar  3 15:28 test1.txt 

az újonnan létrehozott test1.txt fájl sem mások, sem a csoport által nem lesz írható – az előző test.txt pedig írható a csoport által.

Minden fájl 3 időbélyeget tartalmaz, ezek a fájlt leíró adatstruktúrában, az i-node-ban vannak tárolva.

A fenti ls parancsok, amennyiben a -t kapcsoló nélkül használjuk őket kijelzik a megfelelő időbélyeget és név szerint rendeznek. A -t kapcsolóval a megfelelő időbélyeg szerint lesznek rendezve

$ ls -lt
total 16
-rwxrwxr-x 1 lszabo lszabo 4847 Feb  7 16:34 a.out
-rw-rw-r-- 1 lszabo lszabo  198 Feb  7 10:43 echoarg.c
-rw-rw-r-- 1 lszabo lszabo  232 Feb  7 10:43 echo.c
$ ls -ltr
total 16
-rw-rw-r-- 1 lszabo lszabo  232 Feb  7 10:43 echo.c
-rw-rw-r-- 1 lszabo lszabo  198 Feb  7 10:43 echoarg.c
-rwxrwxr-x 1 lszabo lszabo 4847 Feb  7 16:34 a.out
$ 

Az időbélyegek egy egész számot tartalmaznak a fájlt leíró adatstruktúrában, amelynek típusa UNIX időbélyeg (UNIX timestamp). Ez az 1970 január 1 éjfél óta eltelt szekundumok számát jelenti.

Mivel a legtöbb program bemenetet olvas és kimenetre ír, ezek pedig nem feltétlenül igazi fájlok, hanem sokszor különböző bemeneti eszközök, ezért ezeket illetve más speciális adatot is a rendszer fájlként kezel. Így pl. a könyvtárakat is fájloknak tekinti. A rendszer az alábbi fájltípusokat különíti el:

Megjegyzés: a lista azokat a típusokat tartalmazza, amelyekkel a leggyakrabban találkozunk, a különböző Unix változatokon más típusok is vannak, mint a pipe vagy door.

Az eszközillesztést csatlakoztató fájlok, a /dev könyvtárban vannak. Jellegüket tekintve háromféle eszköz van: blokk eszköz (pl. merevlemez partíció), karakter eszköz (pl. terminál) illetve pseudo eszközök (ilyen pl. a /dev/null vagy a /dev/zero).

Linux rendszereknél itt találhatóak például a merevlemezekre mutató eszközfájlok, pl. /dev/hda1 az első lemez első partíciója, /dev/hda2 az első lemez második partíciója, /dev/sda1 az első SCSI vagy soros IDE lemez első partíciója.

Ezekkel a speciális fájlokkal általában rendszergazdai szerepkörben találkozunk, a mindennapi interaktív munkában viszont gyakran használunk hivatkozásokat vagy linkeket.

A UNIX fájlrendszerben gyakran dolgozunk ún. hivatkozásokkal: ez azt jelenti, hogy egy fájl vagy könyvtárnak kettő vagy akár több nevet is adunk, többnyire azért hogy kényelmesebben dolgozzunk a rendszerrel, vagy elkerüljük a szükségtelen kettőzéseket. Kétféle hivatkozást alkalmaz a rendszer: a kemény vagy hard linket és a szimbolikus linket.

A kemény linkek esetében két névvel hivatkozunk egy fájlra, mindkét név egyenértékű. Ilyenkor ha az egyiket megszüntetjük (töröljük a fájlt), a fájl megmarad a másik név alatt (mindegy, hogy melyik névvel volt létrehozva).

A szimbolikus linkek esetében a második név csak egy mutató az elsőre. Ilyenkor, ha az első név szerint töröljük a fájlt, a fájl is törlődik, és a második név a semmibe mutat. Akárhány linket létrehozhatunk egy fájlra. Kemény (hard) hivatkozásokat csak ugyanazon a fájlrendszeren található fájlnevek közt hozhatunk létre, a szimbolikus linkek átmutathatnak fájlrendszerek fölött (fájlrendszer alatt itt például egy merevlemez partíción található fájlrendszert értünk, amelyet felcsatolunk a könyvtárstruktúrába).

Könyvtárakra nem hozhatóak létre kemény hivatkozások.

Létrehozásuk az ln paranccsal történik, használata:

ln eredeti_név új_név

A szimbolikus linkek esetében ezen kívül a -s kapcsolót kell alkalmazni, tehát:

$ ln 1.txt 2.txt         
$ 

parancs hard linket hoz létre, a

$ ln -s 1.txt 3.txt         

pedig szimbólikusat. Az alábbi listán látszik, hogy a 3.txt szimbolikus link (kis l betű a sor elején). A GNU ls parancsa a név mellett egy -> jellel is jelzi a hivatkozást. A lista második oszlopa pedig a fájlra mutató kemény hivatkozások számát jelzi.

$ ls -l
-rw-rw-r-- 2 lszabo lszabo 5 Sep 21 11:37 1.txt
-rw-rw-r-- 2 lszabo lszabo 5 Sep 21 11:37 2.txt
lrwxrwxrwx 1 lszabo lszabo 5 Sep 21 11:38 3.txt -> 1.txt        
$ 

A parancssoron speciális karaktereket használhatunk akkor, amikor fájlnevekre hivatkozunk. Ezek megengedik az általánosabb neveket, és egyszerre a több fájlra való hivatkozást. Az alábbi táblázatban található jelöléseket lehet használni. Amint látni fogjuk, ezeknek a kezelését a héj végzi.

Bizonyos karaktereknek a héj számára más jelentéssel bírnak, mint eredeti jelentésük. Mielőtt a shell végrehajtaná a parancsainkat, átírja (behelyettesíti) ezeket, ezért metakaraktereknek nevezzük őket. Jellegzetes példa a *, amely a shell számára a munkakönyvtárban található fájlok listáját jelenti.

$ ls {a,b}.txt
a.txt  b.txt
$

A * és ? nem illeszkedik ha a fájlnévben az első karakter a pont: . . Ezek a rendszerben az un. láthatatlan fájlok, például: .bash_profile .

Ha a fájl nevekben a metakarakterek literálisan fordulnak elő, vissza-per jelöléssel használhatjuk őket, akárcsak az elválasztó (szóköz) karaktert. Pl: "piros alma.txt" fájl nevet megadhatjuk így is: piros\ alma.txt. Ennek ellenére, sem a metakatraktereket sem az elválasztó karaktereket nem célszerű fájlnevekben használni.

Itt megadjuk a fejezetben használt parancsok rövid leírását. Részletes információkért a parancsok kézikönyv vagy info lapjait kell átolvasni.

$ ls
1.txt  a.txt  test.txt  x.txt
$ ls -l
total 4
-rw-rw-r-- 1 lszabo lszabo  0 Oct  2 21:30 1.txt
-rw-rw-r-- 1 lszabo lszabo  0 Oct  2 21:30 a.txt
-rw-rw-r-- 1 lszabo lszabo 55 Oct  2 21:30 test.txt
-rw-rw-r-- 1 lszabo lszabo  0 Oct  2 21:30 x.txt
$ 

        
$ ls -lt
total 4
-rw-rw-r-- 1 lszabo lszabo  0 Oct  2 21:30 1.txt
-rw-rw-r-- 1 lszabo lszabo  0 Oct  2 21:30 a.txt
-rw-rw-r-- 1 lszabo lszabo 55 Oct  2 21:30 test.txt
-rw-rw-r-- 1 lszabo lszabo  0 Oct  2 21:30 x.txt
$ 

$ mkdir alpha
$ mkdir -p gamma/beta
$

$ rmdir elso
$ rmdir masodik harmadik
$ rmdir -p negyedik/otodik
$ 

$ chmod 755 a.txt
$ 

$ chmod u+x elso.sh
$ 

$ chmod  u-x, o-w 1.txt        
$ 

$ mkdir elso
$ touch 1.txt
$ #fájlt fájlba
$ cp 1.txt 2.txt
$ #egy fájlt két különböző helyre
$ #több állomnyt ugyanabba a könyvtárba
$ cp 1.txt 2.txt elso/
$ mkdir masodik
$ cp -t masodik/ 1.txt 2.txt
$ tree
.
|-- 1.txt
|-- 2.txt
|-- elso
|   |-- 1.txt
|   `-- 2.txt
`-- masodik
    |-- 1.txt
    `-- 2.txt

2 directories, 6 files
$ # másolás jóváhagyással
$ cp -i 1.txt 2.txt
cp: overwrite `2.txt'? y
$

$ ls
elso  masodik
$ cp elso harmadik
cp: omitting directory `elso'
$ cp -r elso harmadik
$ 

$ # egy fájl törlése
$ rm 1.txt
$ # több fájl törlése
$ rm 2.txt 3.txt 4.txt 
$ #egy könyvtár törlése az alatta levő tartalommal együtt
$ rm -rf elso
$ 

$ rm * 
$ 

$ rm -i * 
$ 

$ #létrehozunk 2 könyvtárat és 2 fájlt
$ mkdir elso masodik
$ touch 1.txt 2.txt
$ #az 1.txt átneveződik 3.txt-vé
$ mv 1.txt 3.txt
$ #minden .txt típusú fájlt az elso könyvtár alá visz
$ mv *.txt elso/
$ #az elso könyvtár a második alá kerül
$ mv elso/ masodik
$ tree
.
`-- masodik
    `-- elso
        |-- 2.txt
        `-- 3.txt

2 directories, 2 files

$

Egy héjprogram vagy shell szkript egyszerű szöveges fájl, amelyet a héj soronként értelmez. Minden egyes sort külön parancsnak értelmez (mintha a parancssorról ütöttük volna be), és egyenként végrehajtja őket. A parancsok indításának szintaxisát láttuk már a terminál használatakor: a parancs nevéből, opciókból (kapcsolók) és argumentumokból áll.

A héj számára a megjegyzést deklaráló karakter a # (kettős kereszt vagy diez, angol: hash mark). Azokat a sorokat amelyekben megjelenik, a kettős kereszt karaktertől a sor végéig megjegyzésnek tekinti a héj, akár interaktív módban adtuk meg, akár egy héj programban (az alábbi példában a héj készenléti jele a $ és a cat valamint a sort programokat indítjuk el egy kis szöveges állománnyal).

$ #fájl tartalmának listázása
$ cat lista.txt
delta
omega
alpha
beta
$ #itt rendezzük a fájlt
$ sort lista.txt
alpha
beta
delta
omega

A cat parancs a standard kimenetre írja a parancssorán megadott szöveges fájlt vagy fájlokat, összefűzi őket (concatenate), használata:

A sort az argumentumaként megadott szöveges fájl sorait rendezi ebben az egyszerű használati módban, rendezés után kiírja őket a terminálra.

A héj programok szövegének első sora speciális. Itt adunk meg információt arról, hogy a szöveges fájlt milyen értelmezővel szeretnénk végrehajtani. A sor egy olyan megjegyzést tartalmaz, amelyben a kettős keresztet azonnal egy felkiáltójel követ (tehát: #!) , utána pedig a kívánt értelmező teljes elérési útja áll.

Így egy egyszerű szkript így néz ki:

#!/bin/bash
echo helló
echo vége

A végrehajtás azt jelenti, hogy elindítjuk a parancsértelmezőt (és ez egy új héj lesz – új folyamat - nem ugyanaz ami alól indítottuk) úgy, hogy argumentumként megadjuk a programot tartalmazó fájlt. A két echo helyén bármilyen a héj számára értelmes program szöveg állhat, egymás utáni parancssorok amelyeket a héj egymás után: mindig az előző lefutását megvárva hajt végre. Ugyanez történik, ha a parancsokat tartalmazó szöveges fájlnak végrehajtási jogot adunk, és azt indítjuk, mintha egy parancs lenne:

$ chmod u+x hello.sh
$ ./hello.sh
helló
vége

Ebben az esetben a héj a fentebb bemutatott első program sor szerint válassza ki a parancsértelmezőt, és ugyanúgy új folyamatot indít. Az indításnál szükségünk van a ./ relatív útvonal megadására, mert alaphelyzetben a munkakönyvtár - ahol a programunk van - nincs a héj PATH változójának listájában.

Amennyiben a bash-t megjelölő sor hiányzik, a héj megpróbálja a szöveget a felhasználó számára beállított alapértelmezett héjjal végrehajtani (ennek nevét a SHELL környezeti változó tartalmazza):

$ echo $SHELL
/bin/bash
$

A jelölés más szkript nyelvek esetében is érvényes, általánosan, ha a shell egy szöveget értelmező programot akar elindítani, pl. egy Perl szkript esetében a sor:

#!/bin/perl

Az héj elérésének útvonala rendszerenként változhat, ellenőrizni kell, ezt a which paranccsal tehetjük meg, amely kiírja egy végrehajtható, és a shell által megtalálható (lásd később a PATH változót) program elérési útját:

$ which bash
/bin/bash

A szkript másik végrehajtási módja azzal a héjjal való végrehajtás amellyel dolgozunk, ezt a source paranccsal tesszük (ugyanezt a műveletet végzi a . - dot parancs is):

$ source hello.sh
helló
vége

A fenti programban használtunk ékezetes karaktereket is, régi rendszerek általában csak ASCII kódolással tudták a karakteret kiírni a terminálra. A jelenlegi rendszerek nagy része, köztük valamennyi Linux disztribúció implicit UTF-8 kódolást használ, tehát elvileg lehet ékezetes karaktereket is használni. A shell LANG vagy LC_ALL változói tartalmazzák a beállított nyelvet és kódolást. Ezt, valamint ha távoli terminálról lépünk a rendszerre, akkor a terminál kódolását is ellenőrizni kell.

$ echo $LANG
en_US.UTF-8
$

Amikor a héj megkap egy parancsnevet, az alábbi lehetőségek közt kezdi keresni a nevet a végrehajtás elvégzéséhez:

Ugyanolyan név esetén a prioritási sorrend alias, függvény, beépített majd külső parancs.

A Bash héjba épített parancsokra leírást a Linux rendszerekben a help paranccsal kapunk. A help argumentum nélkül a beépített parancsokat, argumentummal egy parancs segédletét listázza. Tehát a man 1 echo a Linux külső echo-jának, a help echo pedig a belső echo segédletét írja ki. Bash alatt az ugyanolyan nevű beépített parancs fut a külső helyett (ha nem hivatkozunk a külsőre speciálisan).

A külső parancsok programokat jelentenek, amelyeket a héj meg tud keresni a fájlrendszerben, és a héjat futtató felhasználónak végrehajtási joga van reájuk. Ezeket, ha csak parancsnevükkel adjuk meg a PATH környezeti változóban leírt útvonalakon keresi a héj. Ennek tartalma egy elérési út lista, az elemek kettősponttal vannak elválasztva:

$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/home/lszabo/bin:

Ezekben a könyvtárakban fogja a héj a végrehajtható parancsokat keresni.

Az alias-ok vagy helyettesítő nevek arra szolgálnak, hogy a gyakran használt, több opcióval meghívott programoknak egy helyettesítő nevet adjunk, és gyorsabban, egyszerűbben hivatkozzunk rájuk. Jellegzetes példa a Linuxon az ls parancsot helyettesítő alias, amely színes kiírással hívja meg az ls-t. Létrehozása az alias paranccsal történik:

$ alias ls='ls --color=tty'
  

Amint látható, az alias létrehozás tulajdonképpen a névnek egy karakterláncot feleltet meg, és meghívásakor ez helyettesítődik a parancssorra. A helyettesítő neveknek elsőbbségük van az ugyanolyan nevű parancsokhoz képest amikor meghívjuk őket. Törlésük az unalias , a már definiált alias-ok listázása egyszerűen az alias paranccsal történik.

Hogyan fut le egy egyszerű parancsvégrehajtás? Beépített parancsok esetében a héj végzi ezt. Külső parancsok, azaz programok futtatása során, pl. ha beírjuk parancsként az ls parancsot, az alábbi történik:

Egy parancssoron (az új sor elválasztó karakterig tartó karakterlánc) általában egy programot indítunk el. Megtehetjük, hogy többet indítsunk el egyszerre, ha köztük a ;-t használjuk mint elválasztó jelet.

$ echo "rendezés indul" ; sort szoveg.txt;  echo "vége" 
rendezés indul
vége
$ 

Ilyenkor a második parancs megvárja az elsőt, tehát nem párhuzamosan hajtódnak végre, ugyanaz történik mintha 2 parancssort írtunk volna.

A parancssoron elindított programról azt mondjuk, hogy "előtérben fut"; mivel a terminálra ír, és ilyenkor a héj nem adja vissza a készenléti jelet (prompt): azt jelzi ezzel, hogy nem fogad el új parancsot az előzőleg elindított befejezéséig.

Megtehetjük, hogy a parancsot "háttérben" futtassunk; ilyenkor a héj visszaadja a készenléti jelet, és új parancsot üthetünk be. A háttérben futtatást kétféleképpen válthatjuk ki:

A folyamatnak a Ctrl-Z kombinációval jelzést küldünk: a felfüggesztés tipikus példa erre. Lenyomunk egy billentyűt amelyet egy megszakítás közvetítésére használunk, és azt a héj rendszert vezérlő kernelen keresztül eljuttatja a folyamathoz.

Mindkét esetben a héj 2 számot, egy feladat (job) azonosítót illetve egy folyamat azonosítót ír ki számunkra.

$ sort rendezetlen.txt > rendezett.txt &
[1] 4467
$

Ezek segítségével hivatkozhatunk később az elindított munkára, például az előtérbe hívhatjuk az fg (foreground) paranccsal.

A munkák illetve folyamatok kezelésével, valamint ezek különböző indítási módjával később, a Folyamatok kezelése c. fejezetben foglalkozunk, itt röviden megadtuk a használathoz szükséges szintaxist.

A héj, hasonlóan más programnyelvekhez az információkat, adatokat névvel látja el és változóknak nevezi őket. Részletesen a következő fejezetben foglalkozunk ezekkel. Ebben a fejezetben kimondottan a parancshasználattal kapcsolatos környezeti változók miatt említjük őket.

Egy folyamat a környezetéről (az őt futtató operációs rendszerről, gépről, beállításokról) információkat tudhat meg. Ezeket az információkat változókon keresztül kapja (név-érték párok). Nagy betűs változó nevekkel adjuk meg ezeket, különbséget téve így (a programozó számára) a saját, illetve az operációs rendszertől kapott változók közt. ilyen változót már láttunk: például a végrehajtható fájlok elérési útja, a PATH változó.

Néhány környezeti változót az alábbi listában láthatunk. a beállított változókat a printenv vagy env parancsokkal lehet kilistázni. Például az alábbi változók szinte minden gépen be vannak állítva:

TERM=xterm
SHELL=/bin/bash
USER=lszabo
MAIL=/var/spool/mail/lszabo
PATH=/bin:/usr/local/bin:/bin:/usr/bin:/home/lszabo/bin
PWD=/home/lszabo
EDITOR=/usr/bin/vim
LANG=en_US.UTF-8
HOME=/home/lszabo

Indításkor a héj végigolvas néhány konfigurációs fájlt, ezek változókat állíthatnak vagy programokat indíthatnak, amelyek meghatározzák azt a környezetet amelyben a héj indul.

A konfigurációs fájlok különböznek, attól függően, hogy a héj interaktívan fut vagy szkriptet hajt végre. Az interaktívan futtatott héj esetében a bejelentkezéskor induló héj (login shell) is külön fájlokat olvas. Interaktív héjnak nevezzük azokat a héjakat amelyek direkt a terminállal dolgoznak - onnan kapják a parancsokat. Egy adott szkriptet futtató héj általában nem interaktív.

	Más shell
	Az alábbi konfigurációs fájl nevek a Bash-re érvényesek, más héjak esetenként más indító fájlokat használhatnak.

Egyes konfigurációs fájlok közösek, tehát bármely felhasználó belépésekor értelmeződnek, és a rendszer /etc, konfigurációs fájlokat tartalmazó könyvtárában találhatóak (pl.: /etc/profile, /etc/bashrc). Ezen kívül minden felhasználónak saját fájlai vannak a home könyvtárában (.profile, .bash_profile, .bashrc). Ezeket szabadon szerkesztheti, és amennyiben indításkor automata módon akar változókat, alias definíciókat, stb. beállítani, azt innen teheti meg. A .profile és .bash_profile fájlok a bejelentkezési interaktív héj indításnál értelmeződnek (a megadott sorrendben).

A .bashrc fájl is tartalmaz beállításokat, ezek más interaktívan indított héj indításakor értelmeződnek.

A nem interaktív héjaknak külön indító állomány jelölhetünk ki a BASH_ENV változó segítségével.

Ha állandó jellegű beállításokat akarunk végezni, akkor ezeket a fájlokat kell megváltoztatni. Például, ha gyorsabb interaktív munka miatt létre akarunk hozni egy alias-t, akkor ezt a .bash_profile fájl végére írjuk. A locate program fájlnevek gyors keresésére szolgál, használata:

, kilistázza azokat a rendszeren található fájlneveket amelyekben megtalálható az adott sztring. Ha rövidítve szeretnénk használni, pl. csak:

$ l sztring

, és azt szeretnénk, hogy ezt minden shell indításkor megtehessük, ezt kell írnunk a .bash_profile végére:

alias l='locate'

A héj karakterkészletének beállítása fontos, amennyiben például a magyar nyelv karaktereit akarjuk használni. Ezt a LANG illetve az LC_ kezdőbetűket tartalmazó héj változókkal tehetjük. Két paramétert kell ilyenkor beállítani: a karakterkódolást (encoding) és a nyelvet, esetleg országot amelyben az illető nyelvet beszélik. Az LC_ nevű változókkal (LC_ALL, LC_TIME, LC_NUMERIC) a nyelven kívül különböző helyi beállításokat lehet megadni (idő, számok, stb. formázása).

A nyelvi beállítást, amennyiben nincsenek LC_ változók megadva, elsődlegesen a LANG változó adja meg, ennek lehetséges értékeit (ami függ attól, hogy fel vannak-e telepítve a szükséges szoftverek a rendszerre), a locale -a paranccsal lehet kilistázni.

Az UTF-8 kódolás használata ma már jelentősen megkönnyíti ezeket a beállításokat.

A UNIX egyik alapelve, hogy minden eszközt, hardvert, stb.-it fájlként kezel a virtuális fájlrendszere. Így az eszközökre való írás mindig egyszerű fájlba való írásra vezethető vissza a programok szintjén, ami nagyon leegyszerűsíti kezelésüket. Gyakorlatilag minden rendszer komponens, amelyre írni illetve ahonnan olvasni lehet fájlként viselkedik (a közönséges fájltól kezdve a terminál billentyűzetét keresztül a merevlemezig).

Megjegyzés: a "minden eszköz fájl" állítás (bár általában igaz, és jól használható) alól vannak kivételek, mint pl. Linux alatt a hálózati kártyák.

Egy C nyelven írt program mindig (legkevesebb) 3 fájlt talál nyitva indításkor. Ezeket a programozónak nem kell külön előkészítenie vagy megnyitnia. Ezek: a standard bemenet, kimenet és hibakimenet. Mindhármat fájlként kezeli a héj (akárcsak a C nyelv). Jelölésükre egész számot tartalmazó azonosítókat használ a C nyelv akkor, amikor első szintű fájlkezelő függvényeket használ.

Ezeket az azonosítókat a héj is használja, és a héj által elindított programok gyakran használják ezt a 3 fájlt.

Amennyiben a cat parancsot argumentum nélkül indítjuk, a bemeneti fájl helyett a standard bemenetet fogja olvasni és értelemszerűen a standard kimenetre ír. Így gyakorlatilag a standard bemenetet (ami a terminál használata esetében a billentyűzet) átmásolja terminál kimenetére, ha sorokat kezdünk beírni:

$ cat
alpha
alpha
beta
beta
gamma
gamma
$ 

Több Unix szöveget feldolgozó program működik ezzel a logikával, általában valamilyen műveletet is végeznek a beolvasott szövegsoron, így szűrőknek nevezzük őket. A cat a fenti működési módban egyszerűen átmásolja a standard bemenetet a kimenetre.

Átirányításnak nevezzük az a műveletet, amikor egy adott kimenetre (vagy bemenetről) érkező adatsort egy, az eredetitől különböző kimenetre küldünk (illetve bemenetről fogadunk). Például, egy standard bemenetről olvasó programnak egy fájlból érkező szöveget vagy adatsort küldünk, úgy, hogy a programnak nem lesz tudomása, honnan érkezik a szöveg. A héj néhány metakaraktert használ a standard bemenet és kimenet illetve hibakimenet átirányítására, ezeket átirányítási operátoroknak nevezzük.

#a cat-tel a standard bemenetről olvasunk és standard
#kimenetét egy fájlba küldjük
$ cat > lista.txt
delta
omega
alpha
beta
#a terminálra listázzuk a fájlt
$ cat lista.txt
delta
omega
alpha
beta 
$ 

$ sort < lista.txt > rendezett.txt

$ sort < lista.txt  1> rendezett.txt
$ 

$ echo elso > f.txt
$ echo masodik >> f.txt
$ echo harmadik >> ff.txt
$ cat f.txt
elso
masodik
harmadik
$ 

A csővezetékek kommunikációs csatornák, amelyeken keresztül egy folyamat kimenete egy másik bemenetére irányítható egy rendkívül egyszerű szintaxissal a parancssoron. A deklaráláshoz használt jel a | elválasztójel. Az alábbi példában a cat kimenetét a sort standard bemenetére irányítjuk:

$ cat lista.txt | sort
alpha
beta
delta
omega
$ 

Az átvitel szinkronizációról az operációs rendszer (a kernel) gondoskodik. Az említett átirányítások többször is alkalmazhatóak ugyanazon a parancssoron. Az alábbi parancssoron a lista.txt fájl a cat-ből a sort-ra, onnan pedig a head parancs bemenetére kerül:

$ cat lista.txt | sort | head -1
alpha
$ 

A head szintén szövegsorokat szűrő parancs: a bemenetére kerülő szöveges fájl vagy fájlok első sorait listázza, mégpedig annyi sort, amennyit egész számot tartalmazó opciója megad. Így a fenti parancs kimenete csak a rendezett lista első sora. A head használata:

A listázandó sorok számát megadó kapcsoló opcionális, amennyiben nem adjuk meg, implicit értéke 10.

Itt említjük meg a tee parancsot is, amely sorozatos feldolgozás esetén biztosíthatja egy köztes kimenet elmentését, ha arra később szükség lehet. A tee használata az alábbi:

A parancs a bemenetet a kimenetre és az megadott nevű fájlba írja (a -a kapcsolóval hozzáfűzi, nélküle új fájlt nyit). Az alábbi esetben végrehajtódik ugyanaz a feldolgozás mint a fenti példában, de ezúttal a sort által előállított teljes rendezett lista is elmenésre kerül a rendezett.txt fájlba:

$ cat lista.txt | sort | tee rendezett.txt | head -1
alpha
$ 

A fájlokon kívül eszközöket is használhatunk a ki-és bemenetek átirányításakor. Ilyen például a /dev/null eszköz, amely végtelen sok karaktert teljesen elnyelő kimenetként viselkedik. Erre lehet minden olyan kimenetet irányítani, amelyre nincs szükség: jelenléte felesleges vagy zavaró.

A standard hiba kimenet azonosítója a 2-es, erre íródnak a parancsok hibaüzenetei. Ez lehetővé teszi a parancsok hasznos kimenetének és a hibaüzeneteknek a kettéválasztását. Interaktívan dolgozva a terminálon, a parancsok által az 1-es és 2-es kimenetekre írt szövegek együtt kerülnek a terminál kimenetére. Ha a hibaüzenetek nem érdekelnek, csak a hasznos kimenet át lehet irányítani őket a null eszközre. Ha az 1.txt és 2.txt fájlokról kérünk egy listát az ls-el, amennyiben valamelyik nem létezik az ls hibaüzenete összekeveredik a kimeneten a hasznos információval. Az alábbi példában a wc (word count) paranccsal próbálunk információt nyerni szöveges fájlokról.

$ wc 1.txt
2 2 8 1.txt

A wc az argumentumában megadott szöveges fájl sorainak, szavainak és karaktereinek számát írja ki, a három szám után a fájl nevével. Használata

Opciói megengedik külön a sorok (-l), szavak (-w) vagy karakterek (-c) listázását. Több fájlt is megadhatunk a parancssorán:

$ wc 1.txt 2.txt
 2  2  8 1.txt
 1  1 11 2.txt
 3  3 19 total
$ 

Ellenben ha például a 2.txt nem létezik, ezt kapjuk:

$ wc 1.txt 2.txt
2 2 8 1.txt
wc: 2.txt: No such file or directory
2 2 8 total
$ 

Ha a 2-es kimenetet átirányítjuk a null perifériára, megszabadulunk a hibaüzenet kimenetbe való beszúrásától:

$ wc 1.txt 2.txt 2>/dev/null
2 2 8 1.txt
2 2 8 total
$ 

Vannak esetek, amikor mindkét standard kimenetet (kimenet és hibakimenet) külön-külön fájlba vagy ugyanabba a fájlba akarjuk irányítani. A külön-külön fájlba való irányításhoz mindkét kimenetnek meg kell adni az átirányítást:

$ sort lista.txt  > rendezett.txt  2> hibak.txt
$ 

A parancs lefutásának eredménye és hibái külön fájlokban lesznek rögzítve.

A két kimenet ugyanabba a fájlba való irányítására a megoldás a következő: a kimenetet egy fájlba irányítjuk és utána a hiba kimenetet a kimenetre (a két átirányítás sorrendje számít):

$ sort lista.txt  >  rendezett.txt  2>&1
$

Ilyenkor nyilván semmit sem látunk a terminálon, minden kiírt szöveg (akár eredmény, akár hiba) a naplo.txt nevű fájlba kerül, és onnan olvashatjuk el később. A parancs lefutását pedig meg kell várnunk (nincs készenléti jel csak ha a sort lefutott). Ilyenkor megtehetjük, hogy a feladatot a háttérben futtatjuk (hiszen amúgy sem látunk semmit), az alábbi indítással:

$ sort rendezetlen.txt > rendezett.txt 2>&1  &
[1] 5039
$

Így azonnal új paranccsal foglalkozhatunk, nem kell a sort végére várnunk.

Van olyan eset, amikor a két kimenetet ugyanabba a csővezetékbe szeretnénk irányítani, ezt az alábbi megoldással érjük el:

$ sort rendezetlen.txt 2>&1  |  cat  > rendezett.txt
$

Először a hibakimenetet a standard kimenetre irányítjuk, majd a standard kimenetet vezetjük egy csővezetékbe. Utána a csővezetékéket egy másik program, jelen esetben a cat bemenetére.

A Unix alapú rendszerek a rendszerrel kapcsolatos információkat, konfigurációs beállításokat szöveges állományokban tárolják. Ennek klasszikus példája az /etc könyvtárban található passwd nevű fájl, amelyik a rendszeren regisztrált felhasználók adatait tárolja. A fájl egy sora így néz ki:

lszabo:x:500:500:Laszlo Szabo:/home/lszabo:/bin/bash

A passwd állományhoz hasonló, szöveges mezőket tartalmazó állományokból egy bizonyos mezőt (pl. ebben az esetben a felhasználók nevét) kivágni soronként például a cut nevű paranccsal lehet, bemutatását lásd a fejezet végén.

A passwd állományra alkalmazva, a felhasználók listáját így lehet kivágni:

$ cut -f 1 -d : /etc/passwd
root
bin
daemon
adm
lp
sync
 ... 

Ha szükségünk lenne például az első 5 felhasználónévre rendezett sorrendben, azt így kapnánk meg:

$ cut -f 1 -d : /etc/passwd | sort | head -5
adm
apache
avahi
beaglidx
bin

A héj az adatok, információk tárolására változókat használ. A héj változói három kategóriába sorolhatóak:

Először áttekintjük a változók létrehozásának módját a felhasználó által. Ezeket paramétereknek is nevezik, megkülönböztetve a héj saját illetve környezeti változóitól.

Mivel a héj parancssorai szövegekből épülnek fel, a változók nevét és értékét is egyaránt sztringekben tárolja. A név-érték hozzárendelést az = jel segítségével adjuk meg. Például a:

$ szin=piros
$ 

sor végrehajtása során létrejön az a szin változó piros értékkel. A változónevek az angol Abc betűiből (kis és nagybetű közti eltérés számít) valamint számjegyekből és az _ aláhúzásjel karakterből állhatnak, de nem kezdődhetnek számjeggyel.

Az = jel közvetlenül a változó neve után kell elhelyezkedjen, az érték pedig közvetlenül az = jel után, így hibás az alábbi hozzárendelés:

$ szin= piros
-bash: piros: command not found
$

mert így közvetlenül az = jel után a szóköz áll.

A változó létrehozása dinamikus: akkor jön létre amikor értéket adunk neki, nincs szükség előzetes deklarációra. Amikor a létrejött változót később héj parancsok argumentumaiban használjuk, egy $ jellel és a változó nevével hivatkozunk rá (a héj készenléti jeleként továbbra is a $ karaktert használjuk az alábbi példákban, ne tévesszük ezt össze a nevek előtti $ karakterrel). Tehát $szin lesz a hivatkozott változó, és legkönnyebben az echo paranccsal (részletes bemutatását lásd a következő pontban) tudjuk kiírni:

$ echo $szin
piros 
$ 

A változók tehát sztringeket tartalmaznak, így megtörténhet az is, hogy üres sztringet tartalmaznak, tehát nincs értékük. A Bash alap beállításban a nem definiált változóneveket is üres sztringként értékeli ki (ez a viselkedés megváltoztatható Bash opciók beállításával, illetve tesztelhető, hogy létezik-e a változónév, lásd alább).

$ echo $NEMLETEZO

$ 

A változók értékét idézőjelek közé is tehetjük, ha a változó értéke olyan sztring amelyik elválasztó karaktert is tartalmaz, akkor ezt kell tennünk. Például, ha egy változó értéke a piros alma karaktersor, akkor ezt így adjuk meg:

$ valt="piros alma"
$ 

Egyébként a héj csak a piros sztringet rendelné a változóhoz és úgy értelmezné, hogy az alma egy következő parancs.

Megjegyzés: a másik megoldás a vissza-per szekvencia használata:

$ valt=piros\ alma
$ echo $valt
piros alma
$

Változó nevet a héjból az unset paranccsal törölhetünk:

$ szin=piros
$ echo $szin
piros
$ unset szin
$ echo $szin

$

Háromféle idézőjelet használhatunk a héj programokban: " (idézőjel, macskaköröm angolul: double quote), ' (aposztróf, single quote vagy forward tick) és ` (fordított idézőjel, backtick).

Az idézést az első kettővel valósítjuk meg, ezzel a művelettel levédjük a létrehozott sztringet, így a speciális karakterek egy részének és a kulcsszavaknak a jelentése megszűnik.

A fordított idézőjel a héj parancs helyettesítő műveletét vezeti be régi jelölés szerint, részletesen lásd A parancs helyettesítés alpontot alább. Ezzel tulajdonképpen nem "idézünk".

$ uzenet="Hosszabb szöveg"
$ echo $uzenet
Hosszabb szöveg
$ 

$ szin="piros"
$ echo "Hosszabb $szin szöveg"
Hosszabb piros szöveg
$

$ $ echo 'ez itt egy $jel'
ez itt egy $jel
$ 

$ echo \"piros\"
"piros"
$ echo \'piros\'
'piros'
$ 

$ echo "a $szin a \"kiválasztott\" szín"
a piros a "kiválasztott" szín
$ echo "a $szin a "'"'kiválasztott'"'" szín"
a piros a "kiválasztott" szín
$

$ echo "'"
'
$ echo '"'
"
$ 

A sztringekben a héj nem tudja mindig a változó nevét meghatározni a változó nevek egyszerű használatával, például alábbi esetben, ha adott a szin változó, amelynek értéke "piros", a "pirosalma" szöveget akarjuk kiírni:

$ echo "$szinalma"

meddig tart a változónév? a héj úgy fogja értelmezni, hogy egy új változó nevet használunk, a szinalma nevűt, ezért használunk egy jelölési módot ami ezt egyértelművé teszi. Ilyenkor a változó nevét jelentő karakterláncot {} kapcsos zárójelekkel vesszük körül. Így már egyértelmű a változó nevének megadása:

$ echo "${szin}alma"

Ez a változónevek megadásának általános szintaxisa a parancsoron, ha hivatkozunk a változó értékére. A {} zárójelek elhagyhatóak, ha a sztringben a változó nevét nem betű, számjegy vagy alulvonás jel követi.

A példa azt is szemlélteti, hogy két sztring összefűzését úgy oldjuk meg, hogy egyszerűen egymás után írjuk őket a parancsorra, és a héj elvégzi a műveletet akkor, amikor kiértékeli a parancssort.

A {} jelölés, amely a változók kifejtésének egyik módja, további műveleteket is lehetővé tesz a kapcsos zárójelek szerkezet között különböző operátorokat használva. Így lehetőséget ad a változó kezdeti értékének tesztelésére és beállítására:

Az alábbi kis programban (szin.sh) nem adunk értéket a szin változónak, így első használatkor automatikusan felveszi azt:

#!/bin/bash
echo ${szin:=piros} 
echo $szin 

, elindítva a program kétszer fogja a "piros" sztringet kiírni:

$ bash szin.sh 
piros 
piros 
$ 

A {} jelölés megengedi más, igen hasznos sztring műveletek elvégzését is a Bash és Korn héjakban, az alábbiakat igen gyakran használjuk:

Például:

$ valtozo=abcdef 
$ echo ${#valtozo} 
6
$ echo ${valtozo:2:3}
cde
$
$ echo ${valtozo:3} 
def 
$ 

A {} jelöléssel kapcsolatban további műveleteket találhatunk a Műveletek karakterláncokkal fejezetben.

Változók és sztringek kiírására többnyire az echo parancsot használjuk, amely kiírja saját argumentumainak listáját és utána automatikusan egy új sor karaktert. Használata:

Például:

$ echo ez egy üzenet
ez egy üzenet
$ echo ez egy          üzenet
ez egy üzenet
$ 

Látható, hogy a paraméterként kapott sztringeket írja ki. Két kapcsolója van:

-n Nem ír új sor karaktert.

-e Engedélyezi a következő speciális karakterek értelmezését a sztringekben:

Az echo a leggyakrabban használt parancs a héjprogramokból való kiírásra.

A Bash héj rendelkezik egy printf paranccsal is, amelyet ritkábban, abban az esetben használunk, ha bonyolultabban kell formázni a kimenetet. Meghívása az alábbi:

A formázó sztring nagyjából megegyezik a C nyelvből ismert printf szintaxisával, a kiírt argumentumokat pedig a formátum után, egy listában kell felsorolni, elválasztójelek nélkül:

$ printf "%s %.2f  %s %d\n" "Az eredmény:" "0.733"  "kerekítve:"  7
Az eredmény: 0.73  kerekítve: 7
$ 

Pontos használatával kapcsolatban lásd: man 1 printf .

A héj igen nagy számú belső változót tartalmaz, amelyek megadják a rendszer által biztosított környezet tulajdonságait, illetve konfigurációs lehetőségeket biztosítanak a felhasználónak.

Amint említettük, ezek 2 kategóriába sorolhatóak, a saját és környezeti változók kategóriájába. Nevük konvenció szerint nagybetűs. A saját változókat a set , a környezeti változókat a printenv paranccsal listázhatjuk.

Ezek közt vannak klasszikusak, amelyek szinte minden héjban megtalálhatóak ugyanazzal a névvel, és vannak olyanok, amelyek csak bizonyos héjakra, pl. a Bash-re jellemzőek. Az interaktív munka szempontjából megemlítünk néhányat a fontosabbak közül.

A héj készenléti jelének vagy prompt sztringjének kiírását egy PS1 nevű változó vezérli. Ennek értékét írja ki a héj, de úgy, hogy a benne levő vezérlő karaktersorozatokat átírja. A készenléti jel jelezheti, hogy éppen melyik a munka könyvtárunk, mi a gép neve amin dolgozunk, vagy mi a felhasználó nevünk. Ezeket az információkat vezérlő karakter szekvenciákkal írhatjuk be a PS1 változóba. Például a \h a gép rövid nevét jelenteni, \u a felhasználónevet, \w pedig a munkakönyvtár nevét. Így aPS1="\u@\h $" értékadás után a prompt a felhasználó és a gép nevét írja ki, köztük egy @ jellel. Az összes használható átírást a Bash esetében megtaláljuk a kézikönyv PROMPTING című fejezetében.

A PS2 a másodlagos készenléti jel, ez általában egy > karaktert ír ki. Akkor jelenik meg, ha egy befejezetlen sort írunk a parancssorra, például megnyitunk egy idézőjelet és nem zárjuk azt:

$ msg="Ez egy két sorban
> beírt üzenet"
$ echo $msg
Ez egy két sorban beírt üzenet
$

A PS3 és PS4-el később fogunk találkozni ebben a könyvben.

Ugyanilyen belső változó a már említett PATH, a végrehajtható programok elérési út listáját tartalmazó változó vagy az EDITOR, amely a preferált szövegszerkesztő nevét tartalmazza.

A héj saját változói közül egyesek csak a futó héj számára lesznek láthatóak, mások átadódnak a héjból induló parancsoknak vagy új indított héj (lefuttatott szkript) számára is, ezeket környezeti változóknak nevezzük. A már említett PATH változó átadódik minden új indított programnak illetve héjnak, a PS1 pedig nem.

Az export parancs beírja a héjváltozót a környezeti változók listájába. Használata:

Így lehet például a PATH változó értékét megváltoztatni. Amennyiben azt szeretnénk, hogy a munka könyvtárunk (a . könyvtár) is legyen a keresett könyvtárak közt a parancsok elindításánál, az alábbi parancsokat kell végrehajtani:

PATH=$PATH:.
export PATH

vagy egyszerűbben:

export PATH=$PATH:.

Ha minden bejelentkezéskor szükség van erre, akkor a parancsot be kell írni a .bash_profile vagy .bashrc fájlba (ha a Bash-el dolgozunk).

Az első sor átállítja (újra deklarálja) a PATH változót: a régi mögé odailleszti az elválasztó karaktert (:) és utána a pillanatnyi munkakönyvtár nevét, majd az export héj utasítással beírja a környezeti változók közé, úgy, hogy a héj által indított folyamatok is örököljék.

	Munkakönyvtár a PATH változóba
	A . könyvtárat root felhasználó esetében nem ajánlott a PATH listába betenni biztonsági okok miatt.

Az export -f kapcsolóval függvényneveket ír az export listába, -n kapcsolóval törli a beírt neveket. Az -p opcióval kilistázza azokat a neveket, amelyeket a futó héj exportál.

A héj több speciális változót vagy paramétert tartalmaz, amelyek automatikusan jönnek létre. Többnyire olyan információkat fognak tartalmazni amelyek minden programra jellemzőek és gyakran kerülnek felhasználásra. Néhányat megemlítünk itt, a többit pedig az anyaggal való haladás közben.

Ezeknek a változóknak nem tudunk felhasználóként értéket adni, azok is automatikusan állnak elő.

Nevük általában egy speciális karakterből áll, így nagyon gyorsan be lehet írni őket. Például a parancssor argumentumait az 1, 2, 3, ..., 9 nevű változókkal lehet elérni, így $1, $2, ... $9 -ként hivatkozunk reájuk. A parancssoron található argumentumok számát pedig a # változó tartalmazza. Ezek a kapcsos zárójeles szintaxissal is elérhetőek. Az alábbi szkript (arg.sh) például kiírja első és harmadik argumentumát, valamint az argumentumok számát:

#!/bin/bash
echo $1
echo ${3}
echo a parancssor $# argumentumot tartalmaz

, végrehajtva:

$ bash arg.sh elso masodik harmadik
elso
harmadik
a parancssor 3 argumentumot tartalmaz
$ 

Az következő szkript (valtozok.sh) az első paraméter hosszát és első karakterét írja ki a {} jelölés operátorait használva:

#!/bin/bash

#ellenőrzés
str=${1:? nincs paraméter}

echo a paraméter hossza ${#str}
echo első karaktere: ${str:0:1}

, lefuttatva:

$ bash valtozok.sh
valtozok.sh: line 4: 1:  nincs paraméter
$ bash valtozok.sh piros
a paraméter hossza 5
első karaktere: p
$ 

Még két speciális változót említünk itt meg: az @ és a * változókat. Mindkettő a parancssor összes argumentumát tartalmazza, azzal a különbséggel, hogy az @-ban minden argumentum külön sztringént jelenik meg, a * -ban pedig egy sztringként, a héj implicit elválasztó karakterével elválasztva (ez a szóköz, tabulátor vagy újsor). Ha a parancssor argumentumai például az alpha, beta és gamma sztringek:

bash args.sh alpha beta gamma

akkor a "$@" jelölés az: "alpha" "beta" "gamma" sztringet tartalmazza, a "$*" pedig a: "alpha beta gamma" sztringet. Ha egy szkriptben echo-val kiírjuk ezeket, nem látunk semmi különbséget, de abban az esetben, ha paraméterként továbbadjuk őket egy másik struktúrának, vannak különbségek, amint azt látni fogjuk.

Parancs helyettesítésnek azt a műveletet nevezzük, amely során a héj lefuttat egy parancsot, és a parancs kimenetét (a standard kimenetet) mint egyetlen karaktersort egy változóhoz rendel.

Két jelölést használunk erre, egy hagyományosat és egy modernet. Hagyományos jelölés:

változó=`parancssor`

, míg a modern:

változó=$( parancssor )

Mindkét jelölés ugyanazt az eredményt idézi elő. Amint azt tapasztalni fogjuk, a $() jelölés jobban olvasható, ezért ezt ajánlott használni, de a gyakorlatban mindkettővel ugyanolyan mértékben találkozhatunk. A POSIX standard az utóbbi, $() jelölés alkalmazását javasolja.

Az alábbi példában az első parancssor echo kimenete nem a kimenetre kerül, hanem az uzenet változóba:

$ uzenet=` echo "ez a kiírni való" `
$ echo $uzenet
ez a kiírni való
$ 

Ugyanazt érjük el az alábbi jelöléssel:

$ uzenet=$( echo "ez a kiírni való" )
$ echo $uzenet
ez a kiírni való
$ 

A fenti példában az echo kimenete egy 1 soros karakterlánc. Amennyiben nem így van, és a kimenet több sorból áll, a héj átírja az új sor karakter elválasztót egy szóköz karakterré. Ilyenkor egy karakterláncokból álló, szóközzel ellátott listát rendel a változóhoz. Például az ls -1 (úgy listáz, hogy minden egyes fájlnév külön sorba kerül) parancs kimenetét változóba írva egy fájlnév listát kapunk:

$ ls -1
alma.sh  
hello.sh  
phone.sh
$ lista=$( ls -1 )
$ echo $lista
alma.sh hello.sh phone.sh
$

Amint azt az idézőjel használatánál láttuk, a héj a parancssort végrehajtás előtt "átírja": ha vannak benne olyan szerkezetek vagy metakarakterek amelyeket a végrehajtás előtt helyettesíthet, akkor megteszi azt.

A metakarakterek olyan karakterek, amelyek mást jelentenek a héj számára mint betű szerinti jelentésük.

Az alábbiakkal találkoztunk eddig:

A metakaraktereket lehet literális értelemben is használni a parancssoron, de ekkor vissza-per jelöléssel kell megadni vagy aposztróf közé kell zárni őket. Egy *-ot így írunk ki a terminálra:

$ echo \*
*
$ #vagy:
$ echo '*'
*
$ 

A héj bonyolultabb folyamatok közti összefüggéseket is létrehoz amikor a parancssort kiértékeli, erre később még visszatérünk.

Ha tudjuk, hogyan dolgozik a héj a változókkal, megismerhetünk még egy átirányítási műveletet. Ez nem egy parancssorra, hanem egymás után következő szöveg sorokra vonatkozik, ezért leginkább héjprogramokban használjuk. Segítségével a héj program bemenete átirányítható arra a fájlra amelyben a héj program található. Használati módját az alábbi minta adja meg:

parancs  <<  VEGE
itt bármilyen 
       szöveg   állhat
VEGE

A parancs végrehajtása után (ez bármilyen Unix parancs lehet amelyik a standard bemenetről olvas), a héj a parancs bemenetét a saját programszövegére irányítja (az "itt bármilyen szöveg állhat" sorra vagy sorokra), és a parancs addig olvas innen, amíg egy sor elején ugyanarra a karakterláncra akad, amely a << jelek után áll. Itt abbahagyja az olvasást, és a héj végrehajtja a következő soron levő parancsot. Az alábbi héj program egy sorozatlevélhez generál szöveget:

#!/bin/bash

cimzett=${1:? hiányzik az elő paraméter, a címzett neve}

cat << VEGE

Könyvtári figyelmeztető

Kedves ${cimzett}

kérjük hozza vissza a kölcsönkért könyveket.
Üdvözlettel,
Könyvtáros

VEGE

Végrehajtásakor az alábbit látjuk:

$ bash mintalevel.sh Péter

Könyvtári figyelmeztető

Kedves Péter

kérjük hozza vissza a kölcsönkért könyveket.
Üdvözlettel,
Könyvtáros
$ 

Miközben a szöveg átkerül az őt olvasó programhoz (a cat-hez ebben a példában), a héj ugyanúgy átírja, mintha macskakörömmel körülvett sorok lennének: tehát amennyiben a szövegben változók is vannak, azok átírásra kerülnek. A here document átirányítás rendkívül hasznos, ha több példányban kell olyan szövegeket generálni, amelyekben változó mezők vannak.

Fontos: a VEGE szót tartalmazó lezáró sorban akármilyen szócska állhat, de a sornak csak ezt az egyetlen szót kell tartalmaznia a sor elején.

Megemlítjük, hogy a shell rendelkezik egy here string nevű átirányítással is, amellyel egyetlen sztringet lehet egy parancs standard bemenetére küldeni. Az átadás előtt a shell a sztringet átírja. A használt átirányító jel a <<< , tehát így vágjuk ki a b karaktert az "a b c" sztringből::

$ cut -f 2 -d " " <<< "a b c"
b
$

A . (dot) parancs beolvassa és azonnal végrehajtja azokat a shell parancsokat amelyek az argumentumában megadott állományban vannak. Mindezt az éppen futó héjban végzi el, nem indít új héjat, ezért a külső állományból beolvasott változók és definíciók (pl. a függvények) az aktuális héjban maradnak.

Tekintsük a def.sh fájlt, amelynek tartalma:

a=2 
export LANG=hu_HU.UTF-8 

Ha végrehajtjuk a szkriptet egy új héjjal, a definíciók az új héjban jönnek létre, és lefutás után nem lesznek jelen a hívó héjban:

$ bash def.sh
$ echo $a

$

Ez történik minden normál szkript futtatásakor.

Ezzel szemben, a . paranccsal végrehajtva:

$ unset a 
$ echo $a 

$ . def.sh 
$ echo $a 
2 
$ 

Az a változó az aktuális héjban jön létre. Ugyanezt a feladatot végzi a source parancs is:

$ source def.sh 
$ echo $a 
2 
$ 

Az alábbi szkriptek egész egyszerű programok, gyakorlatilag csak változókat használunk benne ismétlődő szerkezetek nélkül.

Írjunk egy szkriptet amelyik kiírja egy állomány N.-dik sorát!

Az alábbi szkript (printline.sh) a feladatot a head és tail parancsokkal oldja meg, kilistázva a fájl első N sorát a head segítségével, utána ennek a listának az utolsó sorát. A paramétereket a ${} szerkezettel saját változóba írjuk át használat előtt. Ennek általában az az előnye, hogy sokkal olvashatóbb szkriptet kapunk amikor felhasználjuk őket.

A tail parancs a fájl végén levő sorokat listázza. A leggyakrabban használt opciója egy szám, amely a fájl végéről listázott sorok számát tartalmazza, ennek implicit értéke 10.

Az alábbi kis szöveget felhasználva:

így listázhatjuk az utolsó 3 sort:

$ tail -3 lista.txt
5 otodik
6 hatodik
7 hetedik
$ 

A szkript paramétereként kapott fájlneveket mindig idézőjelbe tesszük, mert tartalmazhatnak elválasztó karaktereket, pl. szóközt:

#!/bin/bash
# kilistázza egy fájl n.-dik sorát
#
# paraméterek:
#   $1 - fájl név
#   $2 - egész szám
# paraméterek átvétele
file=${1?: hiányzik a fájlnév}
N=${2?: hiányzik a sorszám}
head -$N "$file" | tail -1

a végrehajtás (első alkalommal hibásan):

$ bash printline.sh
printline.sh: line 9: 1: : hiányzik a fájlnév
$ bash printline.sh lista.txt 6
6 hatodik
$

A program csak helyes paraméterekkel működik, nem ellenőrizzük, hogy az N egész szám.

Megjegyzés: a feladatot sokkal egyszerűbben meg lehet oldani a sed paranccsal (lásd 9. fejezet):

$ sed -n 6p lista.txt
6 hatodik
$

Egy másik kis feladat: szúrjunk be egy szöveges fájl első sorának végére egy sztringet, és mentsük el a fájlt más név alatt!

A szkriptben ugyancsak a head és tail parancsokat használjuk.

A fájl végi sorok listázása megadható a tail -n opciójával is:

$ tail -n 3 lista.txt
5 otodik
6 hatodik
7 hetedik
$ 

Ha az opció paramétere előtt + jel van, akkor jelentése: az n.-dik sortól a fájl végéig, ezt fogjuk felhasználni szkriptünkben:

$ tail -n +6 lista.txt
6 hatodik
7 hetedik

Az eddig bemutatott egyszerű eszközökkel így oldható meg a feladat:

#!/bin/bash
# beszúr egy sztringet egy szöveges fájl első sorának végére
# Paraméterek:
#   $1 - eredeti fájl
#   $2 - új fájl
#   $3 - szó
#

#paraméterek átvétele:

f1=${1:? első fajlnév hiányzik}
f2=${2:? második fajlnév hiányzik}
szo=${3:? hiányzik a szó}

#az első fájl első sorát egy változóba írjuk
elso=$( head -1 "$f1")

#hozzáadjuk a szó paramétert
elso="${elso}${szo}"

#létrehozzuk az új fájl első sorát
echo "$elso" > "$f2"

#f2 -be másoljuk a többi sort f1-ből
tail -n +2 "$f1" >> "$f2"

Végrehajtva:

$ bash insfirstline.sh lista.txt lista1.txt " vege"
$ cat lista1.txt
1 elso vege
2 masodik
3 harmadik
4 negyedik
5 otodik
6 hatodik
7 hetedik

Ez a feladat is egyszerűen fejezhető ki a sed paranccsal:

$ sed '1s/$/ vege/' lista.txt
1 elso vege
2 masodik
3 harmadik
4 negyedik
5 otodik
6 hatodik
7 hetedik
$ 

A héjprogramozásban - a klasszikus programnyelvekhez hasonlítva – egy "végrehajtási egységnek" egy kiadott 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. Ezt a vezérlő szerkezetek megadásánál parancssor-nak fogjuk jelölni.

A parancssori szerkezetek végrehajtásának sorrendjét vezérelhetjük. Erre a héj különböző, úgynevezett vezérlő szerkezetet használ.

A strukturált programozás elméletéből tudjuk, hogy egy 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 héj vezérlő szerkezeteit eredetileg az ALGOL68 nyelvet követve alakították ki.

A szerkezetek kialakítása miatt szükségünk van az igaz illetve hamis feltétel fogalmára. Mivel a héj alatt programok, illetve parancsok futnak, a feltételt ezek lefutása után nyert, programok által szolgáltatott kilépési érték vagy állapot (program exit status) jelenti. Ez a C programok kilépése után, az int main()függvény által visszaadott 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 kilépési értékéből áll, amely bekerül a héj speciális ? nevű változójába (és $?-ként érhető el). Ezt az értéket az echo paranccsal tesztelni is lehet:

$ touch 1.txt 
$ ls -l 1.txt 
-rw-rw-r-- 1 lszabo lszabo 0 Oct 12 10:00 1.txt 
$ #végrehajtás után kiírhatom a ? változót amit az ls állított be
$ echo $? 
0 
$ #ha elvégzünk egy hibát adó ls-t
$ ls -l nemletezik 
ls: nemletezik: No such file 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. Például az ls kézikönyve erről ennyit ír: "Exit status is 0 if OK, 1 if minor problems, 2 if serious trouble"). Tehát a tesztek számértéke 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 visszaadott értékeket, így ajánlatos ezeket akár saját C programjaink írásánál betartani. Ez az érték általában egy 255-nél kisebb előjel nélküli egész szám.

Ezek a szerkezetek rendkívül egyszerűen, egyetlen parancssoron alkalmazhatóak a meghívott parancsok között. Amint az sejthető, az && egy és, míg a || egy vagy típusú feltételt fog megoldani az egymásutáni parancsvégrehajtásban.

Az &&, || , 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ódon használhatóak:

$ touch 1.txt
$ #ha hibával fut az ls parancs, kiírok egy üzenetet 
$ ls 1.txt && echo 'van ilyen fájl' 
1.txt 
van ilyen fájl 
$ #ha nem sikerül az ls-t lefuttatni, kiírok egy üzenetet
$ ls 1.txt || echo 'uzenet' 
1.txt 
$ 

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. Tulajdonké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 1.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 1.txt && echo 'van ilyen fájl' || echo 'nincs ilyen fájl' 
1.txt 
van ilyen fájl 
$ ls nemletezik && echo 'van ilyen fájl' || echo 'nincs ilyen fájl' 
ls: nemletezik: No such file or directory 
nincs ilyen fájl 
$ 

A ! operátornak egy jobb oldalon található parancs operandusa kell legyen, segítségével a visszaadott ? változó értéke tagadható:

$ ! ls *.txt 
1.txt  2.txt  felhasznalok.txt 
$ echo $? 
1 
$

	A lexikális egységekre figyelni kell
	A szintaxis itt és az alábbiakban végig eltér a C, Java stb. nyelvekben megszokottaktól: nem írhatunk !ls-t, a parancs értelmezőnek külön lexikális egységként kell látnia a ! illetve az ls sztringeket.

Az parancsok kilépési értékén kívül, gyakran teszteljük az alábbiakat:

A három típusú teszt elvégzését a régi héjakban egy parancsban valósították meg, és ezt ma is használjuk. A parancs argumentumként megkapja a tesztelendő fájlnevet, karakterláncot, számot tartalmazó változót, lefut és kilépési értékében közli a teszt igaz vagy hamis voltát, a már említett fordított logikával. A parancs neve test , és megtalálható külső parancs illetve a héjba é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 fájlné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ó, ami jobban kifejezi a feltétel kiértékelést:

[ kifejezés ]

A test fontosabb kifejezései az alábbiak (a teljes lista megtalálható a kézikönyben, man 1 test, az alábbi opciók megadása a kézikönyv magyar fordítását követi):

Fájlok tesztelése:

-d file   Igaz ha a file létezik és könyvtár.

-e file   Igaz ha a file létezik.

-f file   Igaz ha a file létezik és szabályos fájl.

-L file vagy -h file   Igaz ha a file létezik és szimbolikus hivatkozás (szimbolikus link).

-r file   Igaz ha a file létezik és olvasható.

-s file   Igaz ha a file létezik és 0-nál nagyobb méretű.

-w file   Igaz ha a file létezik és írható.

-x file   Igaz ha a file létezik és végrehajtható.

-O file   Igaz ha a file létezik és az aktuális felhasználó tulajdonában van.

-G file   Igaz ha a file létezik és az aktuális csoport tulajdonában van.

file1 -nt file2   Igaz ha file1 újabb (a módosítási időt tekintve), mint file2.

file1 -ot file2   Igaz ha file1 régebbi, mint file2.

file1 -ef file2   Igaz ha file1 és file2 -nek azonos eszköz- és i-node száma van. Tulajdonképpen ez azt jelenti, hogy hard linkek.

Sztringek tesztelése:

-z string   Igaz ha a string 0 hosszúságú.

-n string   Igaz ha a sztring nem 0 hosszúságú (kétféleképpen lehet tesztelni, a sztring kifejezés ugyanazt jelenti).

string1 = string2   Igaz ha a stringek megegyeznek.

string1 != string2   Igaz ha a sztringek nem egyeznek meg.

Logikai tesztek két test kifejezés között:

! expr   Igaz ha expr hamis.

expr1 -a expr2   Igaz ha expr1 és expr2 is igaz

expr1 -o expr2   Igaz ha expr1 vagy expr2 igaz

Számokat tartalmazó sztringek összehasonlítása:

arg1 OP arg2 az OP operátor valamelyik a következőkből: -eq, -ne, -lt, -le, -gt, -ge . A rövidítések a következő angol kifejezésekből származnak: equal, not equal, less then, less or equal, greater then, greater or equal stb. műveleteket jelentik. Ezek az aritmetikai operátorok igaz értéket adnak, ha arg1 rendre egyenlő, nem egyenlő, kisebb mint, kisebb vagy egyenlő, nagyobb mint, nagyobb vagy egyenlő mint arg2. arg1 és arg2 pozitív vagy negatív egész kell legyen

Példák (a test lefuttatása után azonnal meghívjuk az echo $? parancsot, hogy lássuk a teszt eredményét):

$ touch 1.txt 
$ touch 2.txt 
$ chmod a-w 2.txt 
$
$ # létezik-e a file
$ test -f 1.txt ; echo $? 
0 
$ # könyvtár-e
$ test -d 1.txt ; echo $? 
1 
$ # írható-e
$ test -w 1.txt ; echo $? 
0 
$ # létrehozok 2 sztringet
$ a='abc' 
$ b='def' 
$ # a $a hossza 0 ?
$ test -z $a ; echo $? 
1 
$ # $a egyenlő-e $b-vel
$ test $a = $b ; echo $? 
1 
$ # 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 1 ?
$ test "$x" -lt "1" ; echo $? 
1 
$ 

Valamennyi esetben a [ ] szintaxissal is hívható a test, tehát az utolsó esetre például írhatjuk:

$  [ "$x" -eq "$y" ]  ; echo $? 
1 
$ 

	A [[ ]] szerkezet
	A hagyományos test vagy [] parancs helyett lehet ennek modern változatát, a [[ ]] szerkezetet használni újabb héjakban. Ezt a Bash esetében bemutatjuk a A [[ ]] szerkezet című fejezetben.

Az expr parancsot egyszerű kis műveletek elvégzésére alakították ki héj 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 van jobb megoldás a műveletek elvégzésére és ezt a Bash is átveszi (a (( )) vagy a let szerkezetek, lásd az Aritmetikai kiértékelés ... című fejezetben). Ennek ellenére, használata ma is előfordul, és kezdetnek, két szám közti művelet elvégzésére megteszi. Az expr tud karakterláncokkal is műveleteket végezni. Használata:

expr kifejezés

Az expr a kimenetre írja ki a kifejezés eredményét, és parancssor helyettesítéssel lehet azt egy másik változóba átvenni. Az expr által elfogadott aritmetikai és logikai kifejezések az alábbiak:

arg1 | arg2   arg1 ha az nem 0 vagy null sztring, egyébként arg2

arg1 & arg2   arg1 ha egyik argumentum sem 0 vagy null sztring, másképp 0

arg1 < arg2   arg1 kisebb mint arg2

arg1 <= arg2   arg1 kisebb vagy egyenlő arg2

arg1 = arg2   arg1 egyenlő arg2

arg1 != arg2   arg1 nem egyenlő arg2

arg1 >= arg2   arg1 nagyobb vagy egyenlő arg2

arg1 > arg2   arg1 nagyobb arg2

arg1 + arg2   aritmetikai összeg: arg1 + arg2

arg1 - arg2   aritmetikai különbség arg1 - arg2

arg1 * arg2   aritmetikai szorzat arg1 * arg2

arg1 / arg2   aritmetikai osztás arg1 / arg2

arg1 % arg2   aritmetikai maradéka az arg1 / arg2-nek

Az expr sztring operátorai pedig az alábbiak:

match string regexp   mintaillesztés a string első karakterétől

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 sztringből ahol bármelyik chars halmazban levő karakter található

length string   a string hosszát adja vissza

Például:

$ expr 2 + 3 
5 
$ 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 a héj metakarakerei is. Ezeket vissza-per jelöléssel kell használni, mint például a szorzást, mert először a héj értelmezi, és nyilván átírja őket, ha nem használjuk a \-t :

$ expr 3 \* 4 
12 
$ 

Ugyanebbe a kategóriába esnek a < , > , & , | jelek.

A feltételes végrehajtást az if szerkezettel vezéreljük, ez biztosítja, 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 kilépési értékétől függően dönt a további végrehajtásról. Használata:

if parancssor
then
    parancssor
    . . .
else
    parancssor
    . . .
fi

, vagy többszörös feltétel esetén:

if  parancssor
then
    parancssor
    . . .
elif  parancssor
then
    parancssor
    . . .
else
    parancssor
    . . . 
fi	

A feltételt jelentő parancssorban bármilyen parancs 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 más parancs is.

Az alábbi szkript egy sort próbál beírni egy fájl végére. A test -f opciója a fájl szabályosságát, -w opciója az írhatóságát teszteli.

#!/bin/bash

szoveg="Ezt írjuk a fájl végére."
file="1.txt"


#teszteljük, hogy a fájl nem szabályos fájl
if ! [ -f "$file" ]
then
    echo "$file" nem létezik vagy nem szabályos fájl
    exit 1
fi

#teszteljük, hogy a fájl írható-e
if [ -w "$file" ]
then
    echo "$szoveg" >> "$file"   #szöveg a fájl végére
else
    echo "$file" nem írható
fi

	A [ ] szerkezet szintaxisa
	A test zárójelezésénél a [ ] zárójelek mindkét oldalán egy elválasztó szóközt kell hagyni. A [ és ] lexikális szerkezetek: if [ -w "$filenev" ] # ^ ^ ^ ^ a nyilak fölött szóköz van !!!

Használhatunk 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 :

#!/bin/bash 

#megpróbálok belépni az elso könyvtárba 
 
if cd elso 2>/dev/null 
then 
    echo "sikerült a könyvtárba lépni." 
else 
    echo "nincs elso könyvtár." 
fi 

Ezekben az esetekben nincs szükségünk a feltételként használt parancs kimenetére vagy hibakimenetére, így ezeket a null eszközre vagy napló fájlba irányítjuk. példa (pipes.sh) csővezeték használatára a feltételben:

#!/bin/bash 

#a feltételben egy hosszabb parancssort hívunk meg

if cat /etc/passwd | cut -f 1 -d ":" | sort > felhasznalok.txt 
then 
    echo 'megvan a felhasználók listája' 
else 
    echo 'nem sikerült előállítani a listát' 
fi 

Csővezeték mint feltétel

Az if szerkezet a csővezeték utolsó parancsa által beállított ? változót kapja meg. A parancssor lefuthat úgy is, hogy valamelyik előző program hibásan fut, de az utolsó mégis igaz kimenetet ad. Ha a fenti programban elírjuk a passwd fájl elérési útját, például /etc/passw-t írunk helyette, a szkript lefut, de az első csővezeték üres bemenetet kap: ennek ellenére az üres felhasznalok.txt létrejön. A Bash ennek kivédésére az utolsó lefuttatott csővezeték összes parancsának kimeneti értékét egy PIPESTATUS nevű környezeti változóban adja vissza, amely egy tömb. Ez a 0 indextől kezdve tartalmazza a csővezeték első, második, stb. parancsának kilépési értékét. Fontos szkripteknél ezt tesztelni lehet. Ebben a tananyagban nem foglalkozunk a Bash tömbökkel, a részletek erről a Bash kézikönyvében (BashRef2010, 6.-dik fejezet).

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 1.txt fájlt ha az írható és a mérete 0 byte:

#!/bin/bash

#az első argumentum a fájlnév

file=${1:? hiányzik a fájlnév}

#teszteljük, hogy írható-e a fájl és hossza 0 -e?
#a hossz tesztelésénél megnézzük, 
#hogy mérete nagyobb-e mint 0 byte és tagadjuk ezt

if [ -w "$file" ]  &&  ! [ -s "$file" ]
then
    rm "$file"
    echo "$file" törolve
else
    echo "$file" hossza nem 0 vagy nem írható
fi

(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 (valamit végre kell ott hajtani). Amennyiben a programozás során mégis üres ágat akarunk használni, a héj üres utasítását kell használnunk, a melyet a : szimbólummal hívunk meg. Ez semmit nem végez, de egy igaz értéket hagy a ? változóban:

if [ -w "$file" ]  && ! [ -s "$file" ] 
then 
    rm "$file" 
    echo $file törolve 
else   
    :
fi 

A héj hagyományos for ciklusa egy listán végez iterációt. A lista elemei sztringek. Használata:

for  i  in  lista
do
    parancssor
done

A parancssor-ban az i változó használható, és sorra felveszi a lista elemeinek értékét. A lista megadása opcionális: amennyiben elhagyjuk, használata így alakul:

for  i  
do
    parancssor
done

ekkor az i változó a parancssor paraméterein iterál, tehát a @ változóban található sztringeket járja végig.

Példák:

Egy megadott lista végigjárása (for1.sh):

#!/bin/bash

for i in abc def ghi
do
    echo $i
done

sorban az abc, def, ghi karakterláncokat fogja kiírni. Futtatásnál ezt látjuk:

$ bash for1.sh 
abc 
def 
ghi 
$ 

Ha pl. számokat akarunk végigjárni, akkor számokat ábrázoló sztringeket a seq paranccsal generálhatunk (for2.sh):

#!/bin/bash
for i in $(seq 1 5) 
do 
    echo $i 
done

futtatva:

$ bash for2.sh 
1 
2 
3 
4 
5 
$

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 1. Pl. a seq 1 10 kiírja a terminálra 1-től 10-ig a számokat, a seq 1 2 10 hívás csak minden második számot írja ki.

Egy könyvtárban található fájlneveket az alábbi ciklussal járjuk végig (for3.sh):

#!/bin/bash

for f in $( ls ) 
do 
    echo $f 
done 

lefuttatva:

$ bash for3.sh 
1.txt 
2.txt 
$

A Bash itt az ls parancsot és nem az ls aliast hívja meg, ezért a visszaadott listába nem kerülnek színes kijelzést vezérlő karakterek, ami általában jellemző az ls alias-ra, ha az definiálva van.

Az alábbi példa (for4.sh) a következőket végzi:

A programban használjuk a date parancsot, ez egyszerű hívásnál a pillanatnyi dátumot és időt írja ki. Az exit kilépési parancs paramétere a kilépési kód (lásd alább). Ez 0, ha a program jól futott le, és 0-tól különbözik, ha hibával lépünk ki.

A date kimenete az alábbi:

$ date
Mon Mar 14 23:55:45 EET 2011
$ 

A szkript:

#!/bin/bash

#a napló fájl a home könyvtárban van
NAPLO="$HOME/naplo.log"     #ez a napló
BACKUP="$HOME/backup"       #ide másolunk
PN="for4.sh:"               #ezt  programnevet írjuk a naplóba

#létezik-e a backup könyvtár
if ! [ -d "$BACKUP" ]
then
    echo "A $BACKUP könyvtár nem létezik"
    exit 1
fi

datum=$(date)  #a date parancs a futás időpillanatát
               #rögzíti egy változóban

#ha a programot argumentumok nélkül indították
if [ $# -eq 0 ]
then
    echo $PN $datum "argumentum nélküli végrehajtás" >> "$NAPLO"
    exit 1
fi

#ez a lista kerül a program végén a naplóba
lista=""

#a $@ parancsori változókat tartalmazó listán iterál
for file
do
    if cp "$file" $BACKUP 2>/dev/null  #hibaüzenet eldobva
    then
        echo "$file" elmentve
    else
        #ha nem sikerül, akkor beírom a listába
        #például a fenti masolást könyvtárra nem lehet
        #végrehajtani
        lista="$lista"" $file"
    fi
done


#a napló végére írjuk ha van valami a listában
if [ -n "$lista" ]  #ha nem üres sztring
then
    echo $PN $datum "Nincs elmentve:" "$lista" >> "$NAPLO"
fi

exit 0

A while illetve until ciklusok feltételét ugyanúgy állítjuk elő, mint az, if szerkezetét, tehát a feltétel valamilyen parancssor, amely beállítja a ? változó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:

while parancssor
do
    parancssor
    . . .
done

valamint:

until parancssor
do
    parancssor
    . . .
done

Megfigyelhető, hogy a héjban minkét ciklusnak az elején van a teszt. A while ciklust sokkal gyakrabban használjuk, ebben a tananyagban szinte minden esetben a while-t alkalmazzuk.

A while ciklus használható valamilyen rendszerbeli feltételtől függő ismétlésre. Ha a ciklusban nem végzünk olyan tevékenységet, amely késleltetne, és a ciklus elszabadulhat nagyon gyors, hosszú idejű ismétlésre, ajánlott egy késleltető parancsot használni, amelyik rövid időre felfüggeszti a végrehajtást. A sleep parancs (részletesen lásd a fejezet végi feladatokban) egy megadott ideig függeszti fel a szkript futását, pl. 1 szekundumot várakoztat a sleep 1 hívás.

Az alábbi ciklus arra vár, hogy a teszt.txt fájl megjelenjen. Ezt 1 másodpercenként ellenőrzi.

#!/bin/bash

while ! [ -f teszt.txt ]   # teszt.txt reguláris fájl (létezik?)
do
    sleep 1                # vár 1 másodpercet
done

echo teszt.txt megjelent!

Az alábbi pedig egy klasszikus, egész számmal vezérelt ciklus:

#!/bin/bash

n=5                      #n számértéke kezdetben 5
echo $n

while [ $n != 0 ]
do
    sleep 1

    n=$( expr $n - 1 )   # n=n-1

    echo $n
done

Az expr kissé nehézkessé teszi a számláló csökkentését, a (( )) szerkezettel megoldható ugyanez elegánsabban (lásd 8. fejezet).

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 héj read parancsát használjuk (használatának részletes ismertetését lásd a fejezet végén). A

read line

parancs hívás egy sort olvas a terminálról a line változóba.

#!/bin/bash 

end="end" 

#addig olvas sorokat a terminálról, amíg begépeljük 
#az "end" sztringet 

while [ "$line" != "$end" ] 
do 
    read line 
done 

A read feltételként is kényelmesen használható, mert hamisat térít vissza ha a beolvasás nem sikerül (pl. Ctrl-D fájl vége karaktert kapott bemenetként). Az alábbi kis program például egy nagyon egyszerű szűrőként működik. Beolvas sorokat a bemenetről (ami átirányítás esetén akár egy fájl is lehet), feldolgozza és kiírja őket.

#!/bin/bash
while read line
do
    #sor feldolgozasát itt lehet elvégezni
    # ...
    echo $line               # sor kiírása
done

Megjegyzendő, hogy a fájlok soronkénti feldolgozására alkalmasabb olyan parancsokat használni, amelyeket eleve erre írtak (wc, uniq, tail, cut, egrep, stb.), mert azok sokkal gyorsabban teszik ezt mint egy while ciklus a héjban. Mégis, amennyiben nem áll rendelkezésünkre megfelelő parancs, ezzel a módszerrel dolgozhatunk fel egy sorokból álló bemenetet.

Az until ciklus akkor hasznos, ha valamilyen eseményt kell figyelni, és van egy változó amelyik a ciklus végrehajtása közben kap értéket. Ennek ellenére, nagyon ritkán használjuk. Az példában ( until.sh ) akkor lépünk ki a ciklusból, ha a line változó végleges értéket kap:

#!/bin/bash
#
#az until szerkezet ciklus negatív logikaval

#a teszt azt figyeli, hogy mekkora a $line változó hossza

#az első  ciklusban a line változó nem létezik
#így a test biztos hamis
until [ $line ]
do
    echo 'A $line változó értéke: ' "$line"
    echo "Írja be pontosan az \"abc\" sztringet"

    read line

    #ha nem abc-t ír be, akkor törlöm a változót
    #a shell unset parancsával

    if [ "$line" != "abc" ]; then
        unset line                  #változó törlése
    fi
done

A héj unset parancsa törli a megadott változót.

A két héj szerkezet hasonlóan működik a C-ből megszokott ciklus módosító 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 héj 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 ? változóba). A read parancs -p kapcsolója egy készenléti jelet megadó karakterláncot ír ki.

#!/bin/bash

#végtelen ciklus

while true
do
    read -p "Írjon be egy sort:" line
    #ha nem üres a beolvasott sor kilépek a ciklusból
    if [ -n "$line" ]
    then
        break
    fi
done

A shift "elmozgatja" a parancssor argumentumait egy argumentummal balra, kiejtvén a listából az első argumentumot. Ugyanakkor az argumentumok számát tartalmazó # változó értéke is változik, egyel csökken. Az alábbi példában a szkript kiír minden parancssori argumentumot, de mindig az 1-es változót írja ki. A shift minden ciklusban a átnevezi a 1,. . .,9 speciális változókat, úgy hogy a megfelelő parancssori értékeknek eggyel kisebb számjegy nevű változót rendel. A módosítás amit végez egy elmozgatás: pl. ha a 2-t eltolja 1-be és ha pl. csak 2 paraméter van, a 2 üres változó marad.

#!/bin/bash 

while [ $# -gt 0 ]         #amíg van még argumentum 
do 
    echo  A '$#' értéke: $# , a '$1' értéke: $1 
    shift 
done 

$ ./shift.sh a b c d 
A $# értéke: 4 , a $1 értéke: a 
A $# értéke: 3 , a $1 értéke: b 
A $# értéke: 2 , a $1 értéke: c 
A $# értéke: 1 , a $1 é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.

A héj programokból az exit paranccsal lépünk ki, melynek egy egész számból álló paramétere van, ez lesz a szkript kilépé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.

#!/bin/bash 

#tesztelem, hogy a parancssor első paraméterének 0 -e a hossza 

if [ -z "$1" ] 
then 
    echo legalább egy paraméter szükséges ! 
    exit 1           #hibával lép ki a szkript
fi 

# feldolgozás itt 

exit 0               #jól futott le a szkript 

Ha elhagyjuk az exit 0 -t, akkor az utolsó végrehajtott parancs kilépési értéke marad a ? változóban.

A case vezérlő struktúra hasonló a programozási nyelvek "switch" vezérléséhez: alternatív végrehajtási ágakra bontja a program parancsait. Az alternatívát egy karakterlánc mintákra való illesztése szerint hajtja végre. A következőképpen adjuk meg általános használati formáját:

case valtozó in 
    minta1 ) parancsok ;;
    minta2 ) parancsok ;;
    .  .  .
    mintaN ) parancsok ;;
esac

A szerkezetet case és esac kulcsszavak határolják. A megadott változóra illeszti a következő sorok elején található mintákat. Ahol a minta talál, ott végrehajtja a jobb zárójel utáni parancssorozatot amelyet kettős ; karakter zár le. Csak az első találatnak megfelelő alternatívát hajtja végre.

A minta típusa shell minta (shell pattern): karaktereket illetve az állománynevek megadásánál használatos metakaraktereket lehet használni: * ? [], valamint két minta "vagy" logikával való összekapcsolására a | -at. Példák:

Az alábbi kis példa különböző kiválasztásokat végez a parancssor első argumentumát használva:

#!/bin/bash

valtozo=${1:? nincs paraméter}

case "$valtozo" in
         a) echo kis a betű ;;
    [0-9] ) echo egy számjegy ;;
  *[0-9]* ) echo van benne számjegy ;;
   *.txt  ) echo ".txt" sztringgel végződik ;;
        * ) echo erre nem írtunk pontos kiválasztást ;;
esac

Futtatva:

$ bash case1.sh 2
egy számjegy
$ bash case1.sh a2
van benne számjegy
$ bash case1.sh piros
erre nem írtunk pontos kiválasztást

Az alábbi kis program (case3.sh) a parancssor opcióit elemzi. Ha betartjuk azt a feltételt, hogy egy program hívásakor először a kapcsolókat, utána pedig az argumentumokat adjuk meg (és opciókat nem csoportosítunk) akkor ez a szerkezet alkalmas kis programok opcióinak kezelésére.

#!/bin/bash

#vegigjárja a paramétereket
#a while végén levő shift gondoskodik erről
while [ -n "$1" ]
do
    case $1 in
        -f ) echo f opció ;;
        -c ) #a c kapcsolónak van argumentuma
             #tehát elvégzünk még egy shift-et
             shift
             arg="$1"         
             #itt ellenőrizhetnénk, hogy $1 nem üres sztring
             #de ettől most eltekintünk
             echo c opció, argumentuma "$arg" ;;
        -* ) echo ismeretlen opció: $1
             #ez hiba
             exit 1 ;;
            #ha elérkeztünk az első argumentumhoz,
            #amelyik nem kapcsoló:
         * ) break;;
    esac
    shift  #eltoljuk a paramétereket, $1 -ben a következő paraméter
done

Utolsó mintának a kiválasztásai sorozatban általában érdemes a *-ot használni, ami akkor hajtódik végre, ha az előző kiválasztások közül egyikre sincs találat: így előállíthatjuk a C programozás switch szerkezetének default ágához hasonló szelekciót. A fenti példában ez az ág azokat az paramétereket kezeli amelyek nem kezdődnek - jellel.

A program a -c és -f kapcsolót ismeri fel, ha futtatjuk:

$ bash case3.sh -f -c 33 22
f opció
c opció, argumentuma 33
az elso opciók utáni paraméter: 22

A -c opció paraméterének átvétele előtt még egy shift parancsot kell végrehajtani. Természetesen a paraméter értékét és létezését ellenőrizni kell egy teljesebb szkriptben (megtörténhet, hogy a shift után üres lesz az 1-es változó).

	A getopts függvény
	A héjnak van jobb megoldása az argumentumok kezelésére, a getopts függvény, rövid bemutatását lásd a Függelékek A getops függvény című fejezetében vagy a Bash kézikönyvében. Egyszerű programoknál a fenti megoldás is megteszi.

Az alábbi szkript (case2.sh) pedig különböző típusú állományokat szortíroz a típusnak megfelelő könyvtárba:

#!/bin/bash

#pdf, mp3, avi, jpg, gif típusú állományokat
#külön könyvtárakba válogatja egy forráskönyvtárból
#egy argumentumot vár: a könyvtárnevet ahol az
#állományok vannak

#a célkönyvtárakat az alábbi változókban adom meg
#ezeket is meg lehetne adni paraméterként a parancssoron
PDF=pdf
MP3=mp3
AVI=avi
KEPEK=kepek

#pontosan 1 paramétert vár
if [ -z "$1" ];then
    echo használat: case2.sh könyvtárnév
    exit 1
fi

#a paraméter tartalmát egy jobban olvasható nevű
#változóba tesszük
forras="$1"

#megnézzük, hogy a célkönyvtárak léteznek-e,
#ha nem létrehozzuk őket
for konyvtar in "$PDF" "$MP3" "$AVI" "$KEPEK"
do
    #ha például van pdf könyvtár, akkor az első feltétel
    #után abbahagyja a tesztet
    if ! [ -d "$konyvtar" ]  &&  ! mkdir "$konyvtar" 2>/dev/null
    then
        echo nem lehet a $konyvtar könyvtárat létrehozni
        exit 1
    fi
done

#végigjárjuk a forrás  könyvtár állományneveit
for f in $( ls "$forras" )
do
    #a case-el választjuk és másoljuk különböző helyekre
    #ha egy fájl egyik kategoriába sem esik akkor a *-al
    #jelölt ágra fut
    case "$f" in
        *.mp3 ) mv "$forras/$f" "$MP3" ;;
        *.avi ) mv "$forras/$f" "$AVI" ;;
        *.pdf ) mv "$forras/$f" "$PDF" ;;
  *.jpg|*.gif ) mv "$forras/$f" "$KEPEK" ;;
        * ) echo a "$f" nem tartozik egyik kategoriaba sem. ;;
    esac
done

A select szerkezetet kis interaktív programok esetében használjuk. Használati módja:

select valtozo in lista
do
    parancsok
done

A select kulcsszót tartalmazó sor végrehajtásakor a parancs egy kis menüt ír ki a lista (ez egy sztring lista) segítségével. Ezek után készenléti jelet (prompt) ír ki (ezt a PS3 héj változóból veszi). Válaszként a menü egyik sorát kell kiválasztani úgy, hogy a sorrendjének megfelelő számot ütjük le. Ezek után a select belsejében a valtozo értéke felveszi a listából kiválasztott karakterlánc értékét, és ezt fel lehet használni parancs végrehajtásra. Ugyanakkor a héj REPLY változója felveszi a beütött szám vagy más sztring értékét.

A szerkezet addig ismétli a menü kiírását és a végrehajtást amíg bemenetként állomány vége jelet kap (Ctrl-D) vagy a parancsok végrehajtási részében egy break parancs hajtódik végre. Ha olyan bemeneti számot adunk meg ami nincs a menüben, a változó üres sztringre lesz állítva (a REPLY viszont megkapja a beütött értéket).

Működését az alábbi kis példával illusztráljuk:

#!/bin/bash
#a PS3 értékét beállítjuk, ez lesz a prompt
#csereljük

PS3='>>'

select valtozo in Elso Masodik Harmadik Vege
do
    echo $valtozo
    echo a '$REPLY' valtozo erteke ilyenkor: "$REPLY"

    #itt barmilyen parancsot vegre lehet hajtani, felhasznalva
    #a $valtozo es $REPLY ertekeit

    if [ "$valtozo" = 'Vege' ];then
            echo "...és jön a kilépés a select-ből"
        break
    fi
done

Működése az alábbi:

$ bash select.sh 
1) Elso 
2) Masodik 
3) Harmadik 
4) Vege 
>>1 
Elso 
a $REPLY valtozo erteke ilyenkor: 1 
>>2 
Masodik 
a $REPLY valtozo erteke ilyenkor: 2 
>> 
$ 

Addig ismétli a ciklust, amíg az állomány vége jelet (Ctrl-D) ütjük le vagy kiválasztjuk a 'Vége' opciót.

Sorokat olvas be.

Használat:

Fontosabb opciók:

-p prompt kiír egy készenléti jel karakterláncot olvasás előtt

-s silent: nem használ visszhangot, tehát nem látjuk a leütött betűket: jelszó beolvasásra használjuk

-t timeout vár timeout másodpercig, ha az alatt nem írunk be semmit, visszatér

-n nkar csak nkar 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

Leírás:

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 feldarabolja a sort a héj implicit elválasztói szerint (szóköz és tabulátor) és a változók felveszik a kapott sztringek értékeit. A

read line

tehát az egész sort a line valtozóba téríti vissza, a

read szo1 szo2 szo3

pedig a beírt szavakat a szo1, szo2 stb.-be írja. Elválasztónak a héj implicit elválasztóit használja.

Ha több szó jön a bemenetre mint ahány változót megadunk, az utolsó változóba kerül a fennmaradó szöveg. Pl. ha csak az első szóra van szükségünk, akkor a:

read hasznos szemet

olvasás a hasznos változóba olvassa az első szót, a szemet-be a többit.

Ha elhagyjuk a változónevet, akkor a héj REPLY nevű beépített változójába kerül a bemeneti sor : ez praktikus akkor, ha a bemeneti változót csak a bemenet átvételére használjuk.

A read igaz értékkel tér vissza a ? változóban ha sikerült beolvasnia. Fájl vége (Ctrl-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 1 -t 3 igen_nem
Igen vagy nem [I/N]?:

Ciklusban a while szerkezetben lehet használni mint feltétel:

while read line
do
    #a beolvasott sor feldolgozása
done

Akkor hagyja el a ciklust, ha nem tud olvasni: pl. a bemenet végéhez ér.

Fájlok olvasása a read-el

A read -el csak a standard bemenetről fogunk olvasni ebben a könyvben, ez az implicit működési módja. A parancs tud bármilyen fájlból olvasni, ha megadjuk a fájl azonosítóját. Ezt a -u kapcsolóval lehet elérni. A fájlt 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. Erre adunk most egy példát, de nem fogjuk így használni a read-et. exec 6< "1.txt" #bemeneti fájl megnyitása 6-os azonosítóval read -u 6 line #egy sor beolvasása echo $line exec 6<&- #fájl lezárása Részletek, valamint az összes Bash által a be és kimeneti műveleteknél használt operátor megtalálható a Bash kézikönyvének 3. fejezetében.

Az alábbi kis szkriptekben már kihasználjuk a ciklus szerkezetek által nyújtott lehetőségeket. A példák fájlrendszerhez kötődő kis feladatok.

#!/bin/bash
#átmásol fajlokat egy könyvtárból egy másikba,
#ha a fájlban legalább N szövegsor van
#ha a célkönyvtár nem létezik, létrehozza
#
#Paraméterek:
#   $1 - forráskönyvtár
#   $2 - célkönyvtár
#   $3 - sorok száma
#
#ha nincs pont 3 paraméter, kilép:

if [ $# -ne 3 ]
then
    echo használat: fcopy.sh forrás cél sorszám
    exit 1
fi

#parameterek átvétele
forras="$1"
cel="$2"
sorszam="$3"

#teszteljük a könyvtárakat
if ! [ -d "$forras" ]
then
    echo "$forras" könyvtár nem létezik
    exit 1
fi

#ha a célkönyvtár nem létezik létrehozzuk
if ! [ -d "$cel" ]
then
    if ! mkdir "$cel" 2>/dev/null
    then
        echo nem lehet létrehozni a cél könyvtárat
        exit 1
    else
        #ki is írjuk ha sikerült
        echo "$cel" új könyvtár
    fi

fi

#ellenőrizzük, hogy a célkönytárban tudunk e létrehozni
#fájlokat, van-e w jogunk
if ! [ -w "$cel" ]
then
    echo a "$cel" -ben nem lehet fájlokat létrehozni
    exit 1
fi

#megszámoljuk hány fájlt másolunk
szam=0

#végigjárjuk a forráskönyvtár fájljait
#feltételezzük, hogy csak szöveges fájlok vannak benne
#es ezek elérhetőek
for f in $( ls "$forras" )
do

    #a fájlban levő sorok száma
    N=$( wc -l "$forras/$f" | cut -f 1 -d " " )

    #itt teszteljük a másolás feltételét
    if [ $N -gt $sorszam ]
    then
        #ha teljesül a feltétel másolunk

        #kiírjuk, hány sor van a fájlban, de nem írunk újsort
        #így ugyanabban a sorban fog megjelenni
        #a cp által kiírt szöveg is

        echo -n "$N soros fájl : "

        #használjuk a -v opciót, hogy lássuk mi történik:

        if ! cp -v "$forras/$f" "$cel/$f"
        then
            echo másolás nem sikerült: "$forras/$f" "->" "$cel/$f"
            exit 1
        fi

        #számláljuk a fájlokat
        szam=$( expr $szam + 1 )

    fi
done

echo $szam fájl másolva

$ bash fcopy.sh teszt teszt1 2
teszt1 új könyvtár
4 soros fájl : `teszt/1.txt' -> `teszt1/1.txt'
3 soros fájl : `teszt/2.txt' -> `teszt1/2.txt'
2 fájl másolva
$

#!/bin/bash
# a parancssorán megadott könyvtárat figyeli 2 másodpercenként
# ha az ott levő fájlok száma meghalad egy N számot
# letörli az időben legrégebben módosítottat
# Paraméterek:
#   $1 - a könyvtár neve
#   $2 - az N egész szám
#ha nincs pont 2 paraméter, kilép
if [ $# -ne 2 ]
then
    echo használat: watch_file.sh dir N
    exit 1
fi

#paraméterek átvétele
d="$1"              #könyvtárnév
N="$2"              #fájlok száma

#ha d nem könyvtár kilép
if ! [ -d "$d" ]
then
    echo "$d" nem könyvtár
    exit 1
fi

#számoljuk, hány ciklust végzünk
ciklus=0

#a ciklust a true paranccsal vezéreljük, ez mindig igaz
#így a ciklus végtelen, kilépni csak a szkriptet megszakítva lehet
while true
do
    #megnöveljük a számlálót
    ciklus=$( expr $ciklus + 1 )

    #hány fájl van a könyvtárban
    fileno=$( ls -1 "$d" | wc -l )

    #kifecsegjük a ciklus és fájlok számát
    echo $ciklus ciklus, $fileno fájl van

    #túl sok fájl van?
    if [ $fileno -gt $N ]
    then
        #melyik a legrégebben módosított
        f=$( ls -1tr teszt/ | head -1 )
        #megpróbáljuk letörölni
        if ! rm -f "$d/$f" 2>/dev/null
        then
            #ha ez nem sikerült, kilépünk
            echo vége: nem lehet letörölni a "$d/$f" fájlt
            exit 1
        else
            #kiírjuk a letörölt fájl nevét
            echo "$d/$f" törölve
        fi
    fi

    #várunk 5 másodpercet
    sleep 5

done

$ ls -l teszt
total 0
-rw-rw-r-- 1 lszabo lszabo 0 Aug  2 04:00 1.txt
-rw-rw-r-- 1 lszabo lszabo 0 Feb  2  2011 2.txt
-rw-rw-r-- 1 lszabo lszabo 0 Jan  2  2011 3.txt
-rw-rw-r-- 1 lszabo lszabo 0 Sep 22 17:28 4.txt
-rw-rw-r-- 1 lszabo lszabo 0 Sep 22 17:57 5.txt
$

$ bash watch_file.sh teszt 4
1 ciklus, 4 fájl van
2 ciklus, 4 fájl van
3 ciklus, 4 fájl van
4 ciklus, 5 fájl van
teszt/3.txt törölve
5 ciklus, 4 fájl van

$ 

$ touch teszt/5.txt

$ find teszt -maxdepth 1 -type f
teszt/5.txt
teszt/4.txt
teszt/2.txt
teszt/1.txt
$ 

$ find teszt -maxdepth 1 -type f -print | xargs ls -1tr
teszt/2.txt
teszt/1.txt
teszt/4.txt
teszt/5.txt
$

$ echo bemenet | tr a-z A-Z
BEMENET
$

$ echo abcdef | tr -d ae
bcdf
$

$ echo abbbbbcddddddddddde | tr -s bd
abcde
$

#!/bin/bash
#kiírja a egy szöveges fájl sorait nagybetűkkel,
#minden sor elé írja a sor számát és a sorban levő
#karakterek számat
#Paraméterek:
#   $1 - a fájl neve
#

#csak egy paraméter
if [ $# -ne 1 ];then
    echo hasznalat: sorok.sh fájlnév
    exit 1
fi

#változóba kerül a név
file="$1"

#ha a paraméter nem egy közönséges állomány, kilépek
if ! [ -f "$file" ];then
    echo $file nem közönséges fájl
    exit 1
fi

#kezdeti érték
sorszam=0

#a sorokat úgy olvassuk, hogy a while
#ciklusba irányítjuk a bemeneti állományt
#lásd a done kulcsszó utáni átirányítást

while read line
do
    # a sorszám növelése
    sorszam=$( expr $sorszam + 1 )

    #az egy sorban levő karakterek számának kiszámítása a wc-vel
    karakterek=$( echo $line | wc -c )

    #a sorok végén van az újsor karakter is,
    #így kivonunk 1-et a kapott számból
    karakterek=$( expr $karakterek - 1 )

    #a line változó tartalmát nagybetűssé alakítjuk 
    #a tr paranccsal

    line=$( echo "$line" | tr a-z A-Z )

    #kiírom
    echo $sorszam ':' $karakterek ':' $line

done < "$file"  #itt adjuk meg az átirányítást

$ cat lista1.txt
elso
masodik
harmadik
negyedik
otodik
hatodik
hetedik
$ bash sorok.sh lista1.txt
1 : 4 : ELSO
2 : 7 : MASODIK
3 : 8 : HARMADIK
4 : 8 : NEGYEDIK
5 : 6 : OTODIK
6 : 7 : HATODIK
7 : 7 : HETEDIK
$

A reguláris kifejezések szövegmintákat leíró nyelvet (tulajdonképpen formális nyelvet) jelentenek, segítségével rendkívül könnyen oldhatóak meg keresés, helyettesítés, általában szövegek feldolgozáshoz kötődő feladatok.

Bár konkrétan, mindennapi gyakorlatként először a UNIX-on kezdték használni őket szövegszerkesztőkben (Ken Thompson), jelentőségük túlmutat a UNIX eszközein: ma már minden modern programnyelvbe beépítették őket nyelvi vagy könyvtár szintjen. Ha egy szoftver szövegek feldolgozását is el kell végezze, akkor szinte egyértelműen ezeket használjuk. Így általánosan programfejlesztés közben, adatbányászatban, címkéket használó nyelvekkel való munkában (XML, HTML) vagy a genetikai adatok feldolgozásában nemcsak használatosak, hanem sokszor az első számú eszközt jelentik.

A reguláris kifejezésekkel a UNIX parancsaiban legalább három változatban találkozunk:

Az alapszintű kifejezéseket a régi programokkal való kompatibilitás miatt használjuk. Ilynek például az alábbi Linux/Unix alatt használatos parancsok: expr, grep, sed.

A bővített kifejezéseket az alábbi esetben használjuk: egrep vagy grep -E kapcsolóval, sed -r kapcsolóval, awk, illetve a különböző programozási nyelvekből, ahol a függvények ilyen kifejezést használnak.

A kifejezések variánsai a Unix parancsokban eléggé szerteágazóak, így általában egy új parancs használatánál át kell nézni, hogy milyen típust használ az illető program. Például a vi vagy emacs szerkesztők saját dialektusaikat használják, amelyek eltérnek az említettektől. Ebben a tananyagban a POSIX bővített kifejezéseket használjuk, de megemlítjük a hagyományos BRE kifejezéseket is. A Perl illetve más programozási nyelvekben használatos kifejezések általában bonyolultabbak ezeknél, és szintén nyelvspecifikusak lehetnek.

További tanuláshoz Jeffrey Friedl: Reguláris kifejezések mesterfokon című könyve (Friedl2004) részletesen tárgyalja a reguláris kifejezéseket, beleértve a különböző programozási nyelvekben (Perl, Java vagy .NET-ben) használt variánsokat.

A fejezet elsődleges célja az egrep parancs használatának elsajátítása lesz: a megszerzett tapasztalatot utána más parancsoknál is lehet hasznosítani. Az egrep alapértelmezésben szövegmintákat keres egy szöveges állomány soraiban.

Ebben a fejezetben a reguláris kifejezések jelölésénél a következő megjelenítést használjuk: abc[0-9] . Ha szükséges, a szóközt • , tabulátort → jellel jelöljük. A kifejezésre történő illesztést így emeljük ki: abc7xyz .

A reguláris kifejezések tehát egy olyan nyelvet jelentenek amellyel karakterláncokban megtalálható mintákat írunk le. A minták alatt az egymásutáni karakterek egy jellegzetes sorozatát értjük. Így mintáról beszélünk, ha azt mondjuk, hogy három egymás utáni kis a betű és utána egy kettes, de akkor is, ha általánosabban fogalmazunk, mint pl.: három egymás utáni kis betűt egy számjegy követ.

A mintákat karaktersorozatokban fogjuk keresni, és első megközelítésben csak az angol nyelv karakterkészletével fogunk dolgozni (gépi nyelvekben tulajdonképpen ezek fordulnak elő). Nem foglalkozunk a más nyelven írt szövegek kapcsán használt mintákkal, ezek használata a programoktól függően eltérhet az angol nyelvben használtaktól.

Ha a minta megtalálható egy szövegrészben, akkor azt mondjuk, hogy a minta illeszkedik a szövegre. Az illesztés (match) fogalmával tulajdonképpen egy keresés eredményére utalunk. Pl. a fent említett minták 2 helyen is illeszkednek a aaa2xyxaaa2klm sorozatban. Ilyen kereséskor az első illesztésnek jelentősebb szerepe lehet: sokszor csak az a cél, hogy az elsőt megtaláljuk.

Ha a keresett kifejezés többször fordul elő a feldolgozott sorban, akkor a használt programtól vagy annak futtatási opcióitól függ, hogy keresi-e a második előfordulást, vagy leáll az elsőnél. Az egrep például implicit megkeres minden találatot egy sorban: de vannak olyan futtatási opciói, amikor megelégszik az első találattal (pl. ha csak azt kell megállapítania, hogy egy bizonyos állományban megvan-e a minta, és nem azt, hogy hol).

Bár ezzel nem fogunk foglalkozni, megemlítjük, hogy a keresést véges automatákat használó karakterlánc keresés algoritmusokkal történik. Ezeket egy olyan szoftver komponens hajtja végre a leírt minták alapján amelyet reguláris kifejezés motornak nevezünk (regular expression engine).

A reguláris kifejezésben karakterek és metakarakterek találhatóak: ezek közösen határozzák meg a keresett mintát.

Metekaraktereknek nevezzük azokat a karaktereket amelyek egy reguláris kifejezésben más jelentéssel bírnak, mint a karakter valódi jelenése. Például a ^ karakter amennyiben egy kifejezésben használjuk arra utal, hogy a mintának azt a pontját ahol megjelenik csak a feldolgozott karakterlánc elejére lehet illeszteni.

A minta illesztése egy karakterláncra úgy történik, hogy a motor balról jobbra végigjárja a karakterláncot, és megpróbálja illeszteni a mintát. Egy ilyen feldolgozott karakterláncban külön pozíciót jelentenek a karakterek, de mellettük a karakterek közti üres karakterek is. Így a karakterlánc legelejét nem az első karakter határozza meg, hanem az első karakter előtti üres karakter, és azt is mondjuk ab karakterek között van egy üres karakter.

A következőkben a feldolgozott karakterláncról feltételezzük, hogy az egy egysoros szövegre terjed ki. Így a karakterláncunk végét mindig az újsor karakter előtti üres karakter jelenti. Olyan feldolgozásokról, amelyeknél egyszerre több sorban keresünk (multiline vagy singleline keresés) ebben a tankönyvben nem beszélünk. Azt fogjuk mondani, hogy egy szövegsorban keresünk. Ez az alapszintű shell szkriptekhez elegendő.

Néhány hagyományos program esetében használjuk őket: expr, grep, sed (a sed és grep esetében lehet bővítetteket is használni).

Ezeknél a kifejezéseknél a ?, +, {, |, (, és ) metakaraktereket vissza-per jelöléssel kell használni tehát: \?, \+, \{, \|, \(, és \) -t írunk.

Így pl:. a "legalább egy a betű" minta így fog kinézni: a\+, az "a vagy pontosan 3 b" pedig a\|b\{3\} ; az a minta amelyben megjelöljük visszautalás miatt a 3 egymás utáni kisbetűt pedig így: \([a-z]\{3\}\) .

Ezekben a kifejezésekben nem használhatóak a vissza-per szóhatár szekvenciák.

Ebben a tananyagban nem használunk ilyen kifejezéseket, de a gyakorlatban régi UNIX parancsok szintaxisában előfordulhatnak, például az expr és grep esetében.

A grep parancs kikeresi a bementi szöveges állományokból azokat a sorokat amelyekre a megadott minta illeszkedik, és kilistázza őket különböző opciókkal. Az egyik leggyakrabban használt parancs a Unix rendszereken. egrep nevű változata (vagy -E kapcsolóval indított grep) használja a bővített reguláris kifejezéseket, mi is így fogjuk használni.

Alább a Linux rendszereken általánosan használt GNU egrep változat kapcsolóit ismertetjük (klasszikus UNIX rendszerek egrep parancsaiban nem mindegyik működik ezek közül).

Parancsor formátuma:

Interaktív munkához a –color=auto opcióval indítva a sorok listázásakor színessel írja ki az illesztés helyét, ha a terminál ezt támogatja. Ezt beállíthatjuk egy környezeti változóval is, ehhez írjuk az alábbi parancsot a .bashrc állományunk végére:

export GREP_OPTIONS='--color=auto'

egrep -e '-q' file

Az egrep igaz értéket ad vissza a ? változóban ha talált legalább egy illesztést, és hamisat ha nem talált: ez felhasználható if szerkezetekben, ha feltételként egy egrep-et futtatunk.

Példák az opciók használatára a következő alfejezetben.

A héj igen változatos szerkezeteket biztosít feladataink kifejezéséhez. Ebben a fejezetben néhányat emelünk ki ezek közül, olyanokat amelyeket gyakran használunk mindennapi feladataink megoldásában. Így a fejezet nem csoportosul egyetlen téma köré, változatos nyelvi szerkezeteket járunk be.

Definíció

A függvények általában névvel ellátott kódszekvenciát jelentenek a programozási nyelvekben. A shell esetében is így van, mivel a nyelv interpretált, a függvény nevét és kódját felhasználás előtt, a program szövegében kell definiálni. Ez történhet a szkript elején vagy egy külön állományban, amelyet függvényhívás előtt beolvasunk.

A függvény kód szekvenciáját kapcsos zárójelek közt definiáljuk, a { }-ek közti részt a héj kód blokknak (code block) nevezi.

Ha külön állományban definiáljuk a függvényeket, akkor a . (dot) paranccsal kell őket az főprogramot tartalmazó állományba illeszteni.

A függvények úgy viselkednek mint egy-egy külön kis shell program. Argumentumaikat is ugyanúgy kapják (nem kell argumentumlistát definiálni) és a függvény testében az 1, 2, stb. változókkal érhetők el ($1, $2).

A függvény definíció szintaxisa:

function nev ()
{
  #ide kerül a függvény kódja
}

A nyitó kapcsos zárójel a név sorában is szerepelhet:

function nev () {
  #ide kerül a függvény kódja
}

Ugyanakkor a function kulcsszó akár el is hagyható, tehát a definíció ilyen is lehet:

nev () {
  #ide kerül a függvény kódja
}

Például:

function equal() 
{ 
    if [ "$1" = "$2" ];then 
        return 0 
    else 
        return 1 
    fi 
} 

Fontos: a return parancs a függvény kilépési értékét küldi vissza, ez hívó héj ? változóját állítja be, ennek értéke lesz a return által visszaadott kód, és azt a $? hivatkozással érhetjük el a hívó szekvenciában, tehát nem eredmény visszatérítésre használjuk!

Így a függvény használata:

if equal "$a" "$b" 
then 
    echo egyenloek 
fi 

A függvények megosztják változóikat a hívó héjjal, vigyázni kell tehát a kilépési értékekre illetve a változómódosításra.

Ezek a megosztott változók un. globális változók. Ennek következtében a függvényben láthatóak a hívó szkript változói, és a a függvényben létrehozott változók láthatóak lesznek a hívó szkriptben.

Ha az equal függvényt egy equal.sh állományba írjuk, akkor a . paranccsal az alábbi módon használhatjuk az aktív héjban:

$. equal.sh
$equal "a" "b"
$echo $?
1

A . beolvassa a definíciót, és utána lehet használni ebből a héjból. Függvénydefiníciót törölni az unset parancsot használva lehet:

$unset equal
$equal "a" "b"
-bash: equal: command not found
$

Az unset két opciót fogad el, -v ha csak a megadott változóneveket, -f ha csak megadott függvényneveket akarunk törölni. Opció nélkül mindkettőt próbálja törölni.

A függvénydefiníciót megadhatjuk egyetlen parancssorban:

$ function hello () { echo "Helló" ; return 0; }
$ hello
Helló

Ilyenkor az utolsó parancs után is meg kell jelennie a ; elválasztónak.

Bárhogyan adnánk meg a definíciót, annak meg kell jelennie a kódban a függvény használata előtt (a definíció bárhol lehet, nem kötelező a szkript elejére tenni)!

A függvények nem lehetnek üresek, tehát legalább egy parancsot kell tartalmazzanak.

Függvények érték visszatérítése

Az eredmények visszaadását a hívó szkriptnek az alábbi módszerekkel oldjuk meg:

Az alábbi függvényt a getfname.sh állományban definiáljuk:

#visszaadja az állománynevet, levágva az extenziót
#egy bemeneti paramétere van
#ha több pont van a névben, az utolsótól a végéig vágja le
#a karaktereket
#ha nincs . , akkor a teljes nevet adja vissza

function getfname()
{

    #elhagyjuk az utolsó ponttól
    #a név végéig terjedő szubsztringet

    echo "$1" | sed -r 's/(.+)(\.[^.]*)$/\1/'

    return
}

A sed parancs használatát lásd a parancsot bemutató fejezetben.

A függvény használata:

#!/bin/bash 

. getfname.sh             #függvény definíció betöltése 

fname="file.txt"          

name=$(getfname $fname) 

echo $name 

Az alábbi esetben viszont a függvényben létrehozott line változón keresztül tér vissza az érték (a függvénydefiníció a getline.sh fájlban található):

#egy sort olvas be és azt a line változóban adja vissza 
#a főprogramnak vagy más függvénynek 
#ha a felhasználó  Ctrl-D-t üt be, akkor kilép
 
function getline 
{ 
    line=""
    if ! read -p "Kérek egy sztringet:" line 
    then 
        echo "Olvasás hiba"; 
        return 1 
    fi
    return 0      
} 

Használata:

$.  getline.sh
$ if getline ; then echo $line ; fi
Kérek egy sztringet:piros
piros
$

Környezettel kapcsolatos kérdések

A függvény megkapja a hívó héj munka könyvtárát, környezeti változóit. A függvényben létrehozott változók láthatóak lesznek a hívó héjban, és a függvény is látja az ott előzőleg létrehozott változókat.

Lokális változók használata

A Bash megengedi lokális változók használatát is. Ezeket a local kulcsszóval adjuk meg:

function teszt ()
{
    local valtozo=3

    local eredmeny=$(( valtozo * $1 ))

    echo $eredmeny

}

Ebben az esetben a valtozo és eredmeny változók nem lesz láthatóak a hívó héjban, még csak nem is írják felül az ott található ugyanolyan nevű változókat:

$ . teszt.sh
$ eredmeny=33
$ teszt 8
24
$ echo $eredmeny
33
$ echo $valtozo

$

Rekurzív hívások

Rekurzív hívás lehetséges. Azonban ha a rekurzív feldolgozás számításokat használ, amelyek paraméterként kell átadódjanak egyik szintről a másikra, meglehetősen nyakatekert kódot kapunk. Az alábbi függvény faktoriálist számol, és az eredményt egy fact nevű változóban téríti vissza:

#egy paraméterrel kell meghívni
#n! -t számol
function calc_fact1()
{
    if (( $1 == 0 )) ; then
        fact=1                    #ha n == 0 , akkor fact=1
        return
    else
        calc_fact1 $(( $1 - 1 ))   # (n-1)! marad a 
						  # fact-ban változoban
        fact=$((  fact  *   $1  )) # fact n! lesz
    fi
    return
}

Ugyanez megoldható úgy is, ha az eredményt a ? változóban adjuk vissza, persze ezzel a $? -t nem rendeltetésének megfelelően használjuk. Az alábbi példában az n változót lokálisként használjuk (rekurzív hívások esetében ez a Bash tervezőinek ajánlata), így minden hívás esetében ismét létrejön:

function calc_fact()
{
    local n=$1       #n lokális 

    if (( n == 0 )) ; then
        return 1
    else
        calc_fact $(( n - 1 ))    # (n-1)!
        return $(( $? * n ))      #  n!
    fi
}

Megjegyzendő, hogy a ? változóban a Bash esetében csak 255-nél kisebb egész számot lehet visszatéríteni (tehát annál nagyobb számokra a fenti függvény nem használható).

A rekurzió a héjban lassú, erőforrás igényes és ezért nem javasolt a használata.

A { } elhatárolást függvényeken kívül is lehet használni kódszekvenciák elhatárolására. A { } zárójelek közti szekvencia úgy fog viselkedni, mint egy névtelen függvény.

A { }-ek közti parancsok közös standard bemenet és kimenetet használnak, így alkalmasak közös átirányítási feladatok megoldására: a blokkban található parancsok kimenetét egy állományba lehet irányítani, illetve ugyanazt az állományt több paranccsal lehet végigolvasni.

Amennyiben adott az alábbi számokat soronként tartalmazó be.txt állomány:

és ebből az első két számot egy számítás paramétereiként akarjuk használni, a többit pedig a fájl végéig összeadva egy harmadik paraméterként, az alábbi szkripttel megtehetjük:

#!/bin/bash

{   
    read szam1                      #első számjegy
    read szam2                      #Második számjegy
    s=0
    while read szam                 #ciklusban összeadjuk a többit
    do
        s=$(( s + szam ))
    done

    echo $(( szam1 * s / szam2 ))   #a számítás elvégzése
                        #a Bash-ben ez csak egész számokkal működik 

} < be.txt

Mivel a { } közötti parancsok közös bemenetet használnak, és erre egy fájlt irányítottunk, egymás után olvassák a parancsok a számokat. Ugyanakkor ha szükséges, a szerkezet kimenetét is egy közösen használt állományba lehet irányítani.

A kód blokkban láthatóak a szkript változói, és ha újakat hozunk létre azok láthatóak lesznek a blokkon kívül is. Lokális változók nem használhatók kód blokkban és a héj nem indít külön folyamatot ennek végrehajtására.

A határokat jelző { } kapcsos zárójelek kulcsszónak számítanak (tehát előttük és utánuk elválasztó - implicit szóköz - áll, az utolsó parancs után pedig kötelező a záró ; pontosvessző használata, ha nincs újsor. A fenti szkript egy parancssorban így írható:

$ { read szam1; read szam2; s=0; while  read szam ; \
  do  s=$(( s + szam )); done; \
  echo $(( szam1 * s / szam2 )) ; } < be.txt

Amint láttuk, az expr segítségéve elég kényelmetlen számolni. A 90-es évek fejlesztése során egyes héj értelmezők tartalmaznak néhány olyan kiterjesztést, amely könnyűvé teszi az egész számokkal való számítást (a POSIX szabvány is tartalmazza ezt, így a Korn héj is, valamint 2.04 verziótól kezdve a Bash is). Jelenlétére tehát nem lehet mindig számítani és elvileg hordozható programok esetén kerülni kell.

Ezen kiterjesztések közül a két zárójellel határolt aritmetikai kiértékelést emeljük ki. Egy másik megoldás ugyanerre a feladatra a héjak let parancsa, amely ezzel ekvivalens.

A (( … )) artimetikai kiértékelés szerkezet használata:

valtozo=$(( aritmetikai műveletek ))

vagy, használat közben a terminálon:

$ x=$(( 22 + 6 ))
$ echo $x
28
$ 

A két határoló közti területen aritmetikai műveleteket lehet végezni, ugyanolyan szintaxissal mint a C nyelven történő programozásnál.

A szerkezetet a teszteknél is lehet használni egész számokkal végzett tesztek esetében:

i=4
while (( i > 2 ))
do
    echo $i
    (( i-- ))
done

Szabályok a (( )) használatára:

Az alábbi szkript néhány példát tartalmaz:

#!/bin/bash

#példák számításokra és kifejezés kiértékelésre a (( )) -tel

#néhány segédváltozó 
 
a=1 
b=2 
z=0 

#használhatók a C nyelv operátorai, a változónevek 
#előtt nem kell a $ szimbólumot használni 

echo $(( a + 1)) 

#az sem számít, ha nem tartjuk be feltétlenül a héj által 
#kért szóközöket
 
echo $((a+1)) 
echo $(( a++ )) 

#van egy eset, amikor kell $ szimbólumot 
#használni a nevek előtt: 
#ha a héj speciális változóit használjuk 

if [ -n "$1" ];then 
    echo $(( $1 + 2 )) 
fi 

#a hatvány operátor a **  

echo $(( a**2 )) 

#feltételekben lehet használni

if (( 1 < b )) 
then 
    echo '1 < b feltétel igaz' 
fi 

A (( )) zárójeles szerkezet for ciklusok előállítására is használható, éspedig a C nyelv for utasításához hasonlóan. A szintaxis az alábbi:

for (( i=0; i<10; i++ ))
do
    héj parancsok   #ezekben használható a $i változó 
    . . .
done

Egy egészen egyszerű for ciklust tehát így írhatunk:

#!/bin/bash 
 
for (( i=1; i<=10; i++ )) 
do 
    echo $i
done 

Látható, hogy egész számok végigjárására épülő ciklusokban ez kényelmesebben alkalmazható, mint az előző változatú, sztring lista végégjárására épülő for .

A karakterláncok kezelésénél néha igen hasznos gyorsan elvégezni kis műveleteket, mint például: levágni egy karakterlánc elejét/végét vagy átírni egy részt a karakterláncban. Ezért amikor egy változót kiválasztunk a ${valtozo} szintaxissal, akkor a két {} zárójel közt operátorokat használhatunk erre. Az operátorok az alábbiak:

Példák:

$ a=abcxyzabc 
$ echo ${a#abc} 
xyzabc 
$ echo ${a%abc} 
abcxyz 
$ echo ${a/xyz/abc} 
abcabcabc 
$ 

A duplázott %% és ## használata akkor indokolt, ha olyan mintát adunk meg, amelybe metakarakterek (*, ?) is vannak, amelyek használhatóak. Ezek egy karakterlánc esetében rövidebb vagy hosszabb illesztést is meghatározhatnak. Például, az: abcxyzabcxyz karakterlánc elejére a *abc minta (bármi és utána abc) rövidebben: abc (hiszen az üres karaktereklánc is bármi) vagy hosszabban: abcxyzabc is illeszkedhet. Így a # operátor a legrövidebb illesztést, a ## pedig a leghosszabbat fogja levágni:

$ valtozo=abcxyzabcxyz 
$ echo ${valtozo#*abc} 
xyzabcxyz 
$ echo ${valtozo##*abc} 
xyz 
$ 

Az operátorok könnyebb memorizálása miatt, a következőt tartsuk szem előtt: a # jelet az angolok mindig valamilyen számosság jelölésére használják, és a szám elé teszik, pl. #10 , a % jelet pedig mindig a szám után tesszük, pl. 100% (innen a lánc elejére illetve végére utalás).

Ha van egy változónk amiben egy fájlnév van, könnyen le tudjuk vágni a fájl típusát tartalmazó végződést, és megtartani a nevet (ha pl. más típusra kell átnevezni egy fájl):

$ file="szoveg.txt"
$ echo ${file%.*}
szoveg
$ nev=$( echo ${file%.*} )   #változóba írjuk a nevet
$ echo $nev
szoveg
$ 

Vagy egy hosszú fájlrendszerbeli útvonal részeit lehet gyorsan kivágni:

$ mypath="/elso/masodik/harmadik/szoveg.txt"
$ echo ${mypath#/*/}
masodik/harmadik/szoveg.txt
$ # vagy:
$ echo ${mypath##*/}
szoveg.txt

A [ ] szerkezet jelenti a klasszikus test parancs végrehajtását, ezt a Bourne shell változatok vezették be. A Korn shell egy új teszt szerkezetet definiált 1986-ban, majd a 1993-as változatban véglegesítette ezt. A szerkezetet a Bash is átvette a 2.05 verziótól kezdve.

A [[ ]] a klasszikus teszthez hasonlóan használható. A belsejében a shell nem hajtja végre a shell minták kiterjesztését (*, ?, stb.). Változó helyettesítést, parancs helyettesítést, ~ helyettesítést azonban végez, az idézőjeleket is ugyanúgy használhatjuk mint a parancssoron.

A klasszikus teszt [ ] -nek minden operátorát lehet benne használni:

#!/bin/bash

#az egész számokra vonatkozó tesztek ugyanúgy használhatók 
if [[ $# -ne 1 ]]         # ha $# nem egyenlő 1-el
then
    echo nincs paraméter
    exit 1
fi

file="$1"

#az állományok tulajdonságait lekérő tesztek ugyanúgy 
#használhatóak

if [[ -w "$file" ]]       #írható-e a fájl?
then
    rm "$file"
else
    echo nincs ilyen fájl
fi

A [ ] teszt operátorain kívül a [[ ]] szerkezetben az alábbiak használhatók:

Sztring teszthez: a -n , -z , = és != operátorokon kívül használható a < és > operátorok is amelyek karakter alapú összehasonlítást végeznek :

$ [[ a < b ]]; echo $?
0
$ [[ a > b ]]; echo $?
1

Az == és != operátorok esetében ha az operátor jobb oldalán levő sztringet nem tesszük macskakörömbe, használhatunk shell mintákat is benne. Tehát:

$ [[ "ab" == a? ]] ; echo $?
0

igazat ad vissza, mert a jobb oldali sztring shell minta,

$ [[ "ab" == "a?" ]] ; echo $?
1

viszont hamisat, mert macskakörömben egyszerű sztring a jobb oldali.

A Bash shellben a =~ operátor használható bővített szabályos kifejezésekkel való egyeztetésre . A teszt igazat ad vissza, ha a minta illeszkedik a tesztelt sztringre. Például:

$ [[ "ab" =~ ^a ]] ; echo $?
0

igazat ad vissza, mert a bal oldal a -val kezdődik.

A [[ ]] szerkezeten belül használható a zárójel, ha kifejezést akarunk elhatárolni, illetve az && és || kifejezések közti operátorokként valamint a ! kifejezés tagadására. Pl. azt, hogy az f változóban levő fájlnévhez létezik szabályos állomány és az állománynév .txt-ben végződik így teszteljük:

$ f=a.txt
$ echo a > a.txt
$ [[ -f "$f" && "$f" =~ \.txt$ ]]
$ echo $?
0
$ 

A szövegfeldolgozással kapcsolatos feladatok legfontosabb követelménye a szövegek automatikus, programból vezérelt szerkesztése. Ezt a követelményt biztosítja a sed nevű szerkesztő, amelyik "műfajában" a leginkább használt Unix parancs.

A sed egy speciális szövegszerkesztő, un. folyamszerkesztő program (stream editor). Ez azt jelenti, hogy nem interaktív módban szerkesztünk vele szöveget, hanem a bemenetére vezetjük, a program futás közben végigolvassa azt szövegsoronként és közben szerkesztési műveleteket végez rajta.

Az ilyen folyamot szerkesztő programok rendelkeznek egy parancsnyelvvel, amellyel meg lehet adni nekik a szerkesztési műveleteket. A nyelv segítségével a feldolgozás vezérlésére kis szkripteket írhatunk, ezeket a sed esetében sed szkriptnek fogjuk nevezni.

A szerkesztett szöveg fájlokba vagy egy kimeneti folyamba kerül további feldolgozásra. Így szöveges fájlok szerkesztésére vagy szűrőként valamilyen szövegfeldolgozás köztes állomásaként használjuk.

A sed meghívásának általános alakja:

sed  [opciók] 'szkript' [bemeneti_fájlok]

A sed a vezérlő szkriptet a -e vagy -f opciókkal argumentumaként kaphatja meg, illetve egy karaktersor argumentumként opciók nélkül. A 'szkript' paraméternek akkor kell szerepelnie, ha sem a -e sem a -f opciókkal nem adunk meg más szkriptet.

A feldolgozott szöveg vagy a standard bemenetre jön, vagy fájlnév argumentumként: itt akár több fájl is szerepelhet, a sed sorban fogja feldolgozni őket.

Az alábbi hívások tehát mind helyesek:

Fontosabb opciók:

Ha külön fájlba írjuk a sed programot, annak első sorában a sed-et kell bejelölni mint végrehajtó program, tehát a forrásnak így kell kinézni:

#!/bin/sed -f
#itt soronként jönnek sed parancsok:
1,2 p
3,$ d

A -f opció a végrehajtó programnak azt jelzi, hogy ezt a fájlt kell szkriptként értelmezni.

A sed működés közben követi a vezérlő szkriptben található parancsokat. Egy sed szkript egy vagy több egymás utáni parancsból áll. A sed szkriptben található parancsok formátuma:

[cím] parancs [opciók]

így ezek egy címet, egy szerkesztő utasítást és az utasításhoz tartozó opciókat tartalmaznak, kis feladatokat fogalmaznak meg: "cím : ha az első sor jön a folyamból, parancs: töröld", "cím : a második és harmadik sor közötti részben, parancs: helyettesítsd az a karaktert b -re".

A sed soronként dolgozza fel a bemeneti szöveget. Két pufferel dolgozik, az egyiket mintatérnek nevezi (pattern space), a másikat egy másodlagos tároló puffernek (hold space). A következő algoritmust ismétli:

A sed egyszer olvassa végig a bemeneti szöveget, ha áthaladt egy soron, oda már nem tér vissza

A hold tér arra szolgál, hogy a mintatér törlése előtt speciális parancsokkal sorokat mozgassunk át oda bonyolultabb feldolgozások végett. Így tehát pufferelt feldolgozást is végezhetünk: ezzel nem foglalkozunk, a hold tér használata feltételezi a sed egyszerű működésének jó elsajátítását, ugyanakkor kis héjprogramokban nincs rá feltétlenül szükség.

A sed használható parancssorról, futtathat hosszabb sed szkriptet külön fájlból és használható héjprogramokban kis műveletek elvégzésére. A sed akár több fájlon is elvégez parancssoron kiadott műveleteket ha felsoroljuk azokat argumentumában. Így meghívhatjuk egy-egy önálló feladat elvégzésére szkriptekből is

Szkriptekben a sed parancsot egész kis műveletek kapcsán is használjuk, igen gyakran a helyettesítő s parancsát, ha egy sztringet valamilyen okból szerkeszteni kell. Ilyen pl. a függvényeket bemutató szekcióban az érték visszatérítő példa.

Gyakran használjuk szűrőként, szöveges fájlok előfeldolgozásához. Az alábbi példában adott CSV fájlból például a 3. oszlopot szeretnénk használni, ugyanakkor az első sortól meg kellene szabadulni:

$ cat lista.csv
Tipus  db   Ar  raktar
A   2   22.50    i
B   1   17.80    i
F   2   17.10    n
G   3   1.12    i
H   2   12.10   i
O   1   12.00    n
$

Az alábbi szűrés elvégzi a feladatot (a teljes sorra illesztünk reguláris kifejezést, és helyette csak a kiválasztott mezőt írjuk vissza, miután meggyőződünk, hogy az elválasztók valóban szóközök, és nem tabulátorok):

$ cat lista.csv | sed -r '1d;s/^[A-Z] + [0-9] +([^ ]+).*/\1/'
22.50
17.80
17.10
1.12
12.10
12.00
$

Megjegyzés: a fenti feladatra, különösen ha számolni is kell a kiválasztott számsorral alkalmasabb az awk (lásd Az awk fejezetet).

Szkriptből történő fájl szerkesztésnél viszont inkább a sed-et használjuk.

Például ha egy program konfigurációs állománya gyakran változik, paramétereket kell átírni benne, érdemes annak egy sablont készíteni, és a sablont az aktuális változókra átírni egy szkripttel.

Legyen a kis példa sablonunk (ip.conf.tpl) az alábbi:

A $MY_IP helyett akarunk egy IP címet beszúrni a szerkesztésnél, és az ip.conf.tpl fájlból egy ip.conf nevűt létrehozni. Az alábbi kis szkript elvégzi ezt, paramétere az IP szám:

#!/bin/bash
#változó helyett egy IP számot ír egy konfigurációs
#állomány sablonjába
#Paraméter:
#   $1 - IP szám

#ellenőrizzük, hogy valóban IP szám

TEMPLATE=ip.conf.tpl
CONF=ip.conf

if ! echo "$1" | egrep -q '^([0-9]{1,3}\.){3}[0-9]{1,3}$'
then
    echo make_conf: Nem IP szám: "$1"
    exit 1
fi

sed -r '/^IP /s/\$MY_IP/'"$1"'/' "$TEMPLATE" > "$CONF"

Ellenőrizzük az IP szám formátumát (feltételezzük, hogy a legegyszerűbb alakban jön, és bármilyen számot elfogadunk), majd a sed-et szerkesztőként használva létrehozzuk az új fájlt a kimeneten. Látható, hogy a sed parancshívást több sztringből raktuk össze, mert az aposztrófok közti sed parancssor nem terjesztette volna ki a $1 változó referenciát. A $ metakarakter, így \$-t írunk ahhoz, hogy literálisan jelenjen meg a reguláris kifejezésben. Végrehajtva először hibásan majd helyesen:

$  bash make_conf.sh 192.168.1
make_conf: Nem IP szám: 192.168.1
$  bash make_conf.sh 192.168.1.1
$ cat ip.conf

#tartalom

#IP beállítás
IP = 192.168.1.1

#tartalom

$

Az következő példában (elines_clean.sh) kitöröljük az üres sorokat egy könyvtár szöveges állományaiból, de csak azokban, amelyekben több üres sor van mint egy adott szám. A törlési műveletet egyetlen sed paranccsal végre lehet hajtani, viszont a kiválasztási feltételt egyszerűbb egy szkripttel megoldani.

#!/bin/bash
#törli az üres sorokat azokból a szöveges állományokból
#amelyekben az üres sorok száma meghalad egy N számot
#Paraméterek:
#   $1 - célkönyvtár neve
#   $2 - sorok száma
#

#paraméter átvétel
d=${1:? az első paraméter a könyvtárnév}

#éles szkripteknél ajánlatos ellenőrizni, hogy N egész szám 
#ezt itt nem tesszük meg 
N=${2:? a második paraméter a sorok számának határa}

for f in $( ls "$d" )
do
    #előállítom a célfájl teljes elérési útját egy változóban
    target="$d/$f";

    #ellenőrzöm, hogy a fájl valóban szöveges
    if ! file "$target" | egrep -q 'text'
    then
        echo elines_clean: a "$target" nem szöveges vagy üres
	  #ha nem szöveges, a új ciklus
       continue
    fi

    #hány üres sor van a kiválasztott fájlban
    empty=$( egrep '^$' "$target" | wc -l )

    if (( empty > N ))
    then
      sed -i.bak -r '/^$/d' "$target"
      echo elines_clean: "$target" szerkesztve
    fi
done

Végrehajtva a teszt_sed könyvtáron, amelyet a végrehajtás előtt és után is listázunk:

$ ls teszt_sed
1.txt  2.txt  3.txt  4.txt  5.txt
$ bash elines_clean.sh teszt_sed 3
elines_clean: teszt_sed/1.txt szerkesztve
elines_clean: teszt_sed/3.txt szerkesztve
elines_clean: a teszt_sed/4.txt nem szöveges vagy üres
$ ls teszt_sed
1.txt  1.txt.bak  2.txt  3.txt  3.txt.bak  4.txt  5.txt
$ 

Megjegyzések

A sed -i és -s opciói

Fontos: ha egyszerre több fájlt adunk meg a parancssoron, a kimenet szempontjából a sed egyetlen kimeneti folyamot készít belőlük. Így -i inline szerkesztés esetén meg kell adni, hogy egyenként szerkessze a fájlokat, ezt a -s opcióval tesszük, és így meg lehet adni neki egy több fájlt kiválasztó mintát, mint a *.txt. Külön-külön fogja őket szerkeszteni: $ sed -s -i.bak -r '/^$/d' teszt_sed/*.txt $

Bővített reguláris kifejezéseket használunk, ezért minden esetben alkalmazzuk a -r opciót.

Az Awk egy programozási nyelv, szerzői "Awk, a pattern scanning and processing language": minta elemző és feldolgozó nyelv nevet adták neki. A nyelv tulajdonképpen bármilyen felépítésű szövegből minták alapján mezőket tud kiemelni, és azokkal számítási vagy szerkesztési műveleteket tud végezni. Így akár a Unix programok kimenetét (pl. az ls -l parancs kimenetét) akár adatokat tartalmazó, szövegmezőkre bontható fájlok (pl. a CSV típusú fájlok) soraiból ki lehet vele hámozni egy feladat megoldásához szükséges mezőket. A nyelv programozási szerkezetei a C nyelv utasításaira épülnek. Nevét a szerzők nevének kezdőbetűiből állították össze: Aho – Weinberger – Kernighan. Az Awk rendkívüli módon megkönnyíti a szöveges fájlok feldolgozását. A mérnöki munkában nyers adatok előfeldolgozását végezhetjük vele könnyen.

Mivel szkript nyelv, kis mindennapi feladatok megoldását végezhetjük el vele gyorsan. A nyelv szerzői nem ajánlják a nyelvet nagy és bonyolult feladatok megoldásához: ennek ellenére, elég sok típusú feladatot lehet vele megoldani, különösen azokat, amelyek rendszerprogramozáshoz közeliek, és valós számokkal is kell számolni.

Ez a fejezet az Awk fontosabb elemeit mutatja be. Kimerítő tanulmányozásához a felhasználói kézikönyv is szükséges, amelynek van egy magyar fordítása (Iványi2005). Ebben a rövid bemutatóban a hangsúly a nyelv elveinek megértésén és héjprogramokban való használatán van.

Feltételezzük, hogy az olvasó ismeri a C programozási nyelvet - az Awk nyelv több szintaktikai elemet a C-hez hasonlóan használ, így kis feladatokhoz könnyen elsajátítható néhány egyszerű használati mód azok számára akik programoztak már C-ben. Ha ez nincs így, ajánljuk az előző bekezdésben említett Iványi Péter fordításnak tanulmányozását (vagy az aktuális angol nyelvű kézikönyvet).

Az Awk-nak több változata van, az alábbiak a GNU Awk-ra érvényesek Linux alatt.

A nyelvet értelmező awk parancs indítása hasonló a sed-éhez, a program végigolvassa a bemenetét (a standard input jelenti az implicit bemenetet), feldolgozza azt és a kimenetre ír. A -f kapcsoló ugyanúgy a szkript fájlra hivatkozik, de a szkript megjelenhet az első paraméterben is idézőjelek között.

Néhány fontos, általunk is használt opciója:

A leggyakrabban használt parancssori indítások az alábbiak:

Az első esetben az Awk szkript szövege a parancssoron van, általában aposztrófok között,pl.:

$ awk '{print}' teszt.txt

A {print} szkript egyszerűen kinyomtatja a bemenetre érkező sorokat.

A második esetben a szkript egy fájlban van:

$ awk -f doit.awk teszt.txt

A bementi fájlt megadhatjuk a standard bemenetre is:

$ cat teszt.txt | awk '{print}'  

Az Awk programokat

#!/bin/awk -f 

sorral kezdődően külön fájlba írjuk, melynek az .awk kiterjesztést adjuk, hogy megkülönböztessük őket más szkriptektől (az elérési utat ellenőrizzük a which awk paranccsal saját rendszerünkön).

Megjegyzés: a .awk kiterjesztés nem kötelező, a fájl bármilyen nevű lehet, helyes awk parancsokkal.

Az Awk a következő feldolgozási folyamatot alkalmazza a bemeneti sorokra: úgy tekinti a sorokat, mint egy elválasztó karakterrel (vagy karakter szekvenciával) határolt, mezőkből álló sor. Egy sornak a neve rekord (ez a feldolgozási egység). Pl. az alábbi (zeneszámok szövegeit tartalmazó katalógus egy sora) esetében:

sornak 5 mezője van, az elválasztó egy vagy több szóköz. A sor feldolgozása közben a nyelv a mezőkre a $1, $2, ... változókkal hivatkozik. Pl. a $3 értéke Numb. A teljes sorra a $0 változóval lehet hivatkozni.

A mezőkre az alábbi szerkezettel is lehet hivatkozni:

k=3
print $k

ahol k egy változó (lásd alább hogyan definiáljuk a változókat). Az Awk sor a harmadik mező értékét fogja kinyomtatni .

A sorok számát az Awk az NR (Number of Rows - az összes eddig beolvasott sor) és FNR (az aktuális bemeneti fájl, ha több van) változókban követi.

A mezők száma az FN változóban van, amely az utolsó mező címzésére is használható: $FN. Az alábbi példa:

print $FN

az utolsó mezőt nyomtatja, függetlenül attól, hogy hány van. A mezők címzésére kifejezések is használhatóak:

print $(2+2)

a negyedik mezőt fogja nyomtatni.

Használat közben az Awk által előállított mezőket tartalmazó változóknak meg lehet változtatni az értékét:

$echo 'a b' | awk '{$1="b"; print $0}'
b b

Az Awk programsorok szabályokból állanak: egy szabály egy mintából (pattern) és a hozzá tartozó tevékenységből (action) vagy utasításokból (statement) áll, amely {} közé zárt blokkban van:

minta  {utasítások}

A {} blokkban utasítások követik egymást. A nyelvben függvények vagy nyelvi szerkezetek hívhatóak különböző műveletek elvégzésére. Függvényei közül a legegyszerűbb a print : kinyomtatja a $0 változó tartalmát.

{print}

Ha argumentumokkal használjuk, a print függvény a felsorolt változókat kiírja a kimenetre egy kimeneti elválasztóval (ez implicit egy szóköz):

$ echo '112 LinkinPark Numb numb.txt 35' | awk '{print $1, $4}'
112 numb.txt

Normális menetben az Awk nyelv értelmezője egy-egy sort olvas a $0 változóba, feldolgozza azt: azaz alkalmazza reá szabályait ha a szabályhoz rendelt minta kiválassza a sort. Ezt a műveletet ismétli amíg a bemenetről elfogynak a sorok.

Mintái bővített reguláris kifejezéseket használnak, pl. a: /^a/ azokat a sorokat fogja kiválasztani amelyek a -val kezdődnek.

Az Awk szabályban a mintának vagy tevékenységnek meg kell jelennie. Ha a minta elmarad, a tevékenységet minden bemeneti sorra alkalmazza az Awk, ha a tevékenység marad el, akkor az implicit tevékenység a print $0, azaz a bemeneti sor nyomtatása. Így:

$ echo piros | awk '{print $0}' 
piros

kinyomtatja az egyetlen bemeneti sort, mert a minta illeszkedik a sorra,

$ echo piros | awk '/^p/' 
piros

ugyanazt teszi, mert elhagytuk a tevékenységet de használtunk mintát. Ugyanakkor:

$ echo piros | awk '{print $0}' 
piros

is kinyomtatja a bemeneti sort, mert nincs minta, tehát minden sorra illeszkedik.

A minta felépítése bonyolultabb mint a sed által használté. Az alábbi táblázat tartalmazza a lehetséges eseteket:

$1 ~ /^a/

$ echo "10 szöveg" | awk ' $1 < 9  {print $2}'
$ echo "10 szöveg" | awk ' $1 < "9" {print $2}'
szöveg
$

Az Awk nyelv elemei { } zárójelek közé kerülnek és szabályokat határoznak meg. A C nyelvhez hasonlóan, változó értékadást, kifejezéseket, vezérlő szerkezeteket tartalmaznak. Az operátorok, utasítások a C-hez hasonlóak (a C nyelvet vették mintának a tervezésüknél). Pl.:

{a=2; print a}

Az utasítások közt az elválasztó az újsor karakter illetve, amennyiben egy sorba több utasítás kerül(pl. a parancssoron) akkor a ; .

Az Awk program 3 részt tartalmazhat, egy bevezető (BEGIN), egy szövegsoronként végrehajtható és egy záró (END) programrészt, tehát általánosan így néz ki:

BEGIN {bevezető utasítások} 
minta { a kiválasztott sorra végrehajtott utasítások}
...  
END   {záró utasítások }

A minta {utasítasok} szerkezet egymás után többször is előfordulhat, és ez a rész ismétlődik minden egyes feldolgozott sorra.

$ echo '1 2'| awk 'BEGIN{a=1} {a=a+$1+$2} END{print a}'
4
$ 

A # jel magyarázat beillesztését jelenti a sor végéig, akár a shell esetében.

Az Awk változóneveket ugyanúgy jelöljük mint a C nyelv változóit. A deklaráció pillanatában jönnek létre és típusukat nem kell explicit deklarálni (tehát nem szükséges őket még csak a BEGIN részben sem deklarálni), és a hozzájuk rendelt értéktől vagy kontextustól függően lesznek valósak vagy karakterláncok. A szkript nyelvekre jellemzően ezek dinamikus változók.

A nyelv két adat típussal rendelkezik: dupla pontosságú valós illetve sztring.

s="piros"

egy sztringet hoz létre,

x=2.2

pedig egy valós változót.

y=$10

Az y a $10 mezőtől függően lesz valós vagy karakterlánc.

Ha nem inicializált változóra hivatkozunk, sztring esetében az üres sztringet, valós szám esetében a 0-át adja vissza a nyelv, hibát nem jelez. Pl.:

$awk ' BEGIN {  print s+2; } '
2

Ilyenkor a típus a kontextus szerint alakul: a fenti példában az s változó egy valós kifejezésben (összeadás) vesz részt, így a nyelv 0-ra inicializálja. Egyszerű változókon kívül tömbök is használhatók, ezek asszociatív tömbök (lásd az awk kézikönyvének megfelelő fejezetében).

A program tartalmaz belső változókat, ezek mindig létrejönnek, nem kell őket deklarálni. Közülük az alábbiak fontosabbak, ezeket gyakran használjuk.

Az ARGV illetve ENVIRON változók is hasznosak lehetnek akár kis programokban is, ezek a parancssor argumentumait illetve a környezeti változókat tartalmazzák. Ezek a változók Awk tömbök. Használatukat megtaláljuk az awk kézikönyvében ( lásd Ivanyi2005, Tömbök az awk-ban című fejezet).

A sztring konstansok kettős idézőjellel körülvett sztringek. A sztringeken belül használhatóak a C nyelv vissza-per szekvenciával megadott speciális karakterei, például az újsor ( \n ) vagy tabulátor ( \t ) . A \c literálisan a c karaktert jelenti.

$ awk 'BEGIN {s="abc"; t="def\nitt újsor jön"} END{print s,t}'
abc def
itt újsor jön

A tízes, nyolcas és tizenhatos számrendszerben megadott konstansokat ugyanúgy kezeli mint a C nyelv. Pl:

awk 'BEGIN {print 10.2,011,0x22}'
10.2 9 34

Az Awk a C nyelv operátorait használja, ezek változóira és konstansaira alkalmazhatók.

Az operátorok precedenciája és asszociativitása ugyanaz mint a C nyelvnél. Különbségek:

A sztringek összefűzésének operátora a szóköz karakter, tehát:

{print "a" "b"}

ab-t fog kiírni, két sztringet összefűzni így lehet:

$ awk 'BEGIN {  x="a" "b"; print x  } '
ab

A nyelv nem rendelkezik a vessző operátorral, tehát nem használhatunk ilyen szerkezeteket mint: a=2, b=5 .

Rendelkezik viszont egy sajátos operátorral, amely nem található meg a C nyelvben, a reguláris kifejezés tesztelése (illesztés, match) operátorral. Ezt a ~ jellel adjuk meg, az ellenkező műveletet, azaz a nem illeszkedik tesztet pedig a !~ jelekkel. Az első operandus egy változó, a második pedig egy reguláris kifejezés. Pl.:

if ( s ~ /^a/ ) print "Az s változó tartalma kis a betűvel kezdődik"

Példák az operátorok használatára:

$ #inkrementálás
$ echo '' | awk '{i=0; i++; print i}'
1
$
$ #összeadás
$echo '1.1 2.2' | awk '{ s=$1+$2; print s  }'
3.3

$ #reguláris kifejezés illesztés
$ echo '112' | awk '{if ($1 ~ /^[0-9]+$/)\
  {print "az első mező számokból áll"}}'
az első mező számokból áll
$
$ echo 'abc' | awk '{if ($1 !~ /^[0-9]+$/) \
  {print "az első mező nem áll számokból"}}'
az első mező nem áll számokból
$
$ #pelda sztring összefűzésére
$ echo '1 2 3 abc def ' | awk '{print $4 $5}'
abcdef
$ 

A programok döntés és ciklus szerkezeteinek megoldására un. vezérlő kifejezéseket használ a nyelv. A struktúrákat a C nyelvből kölcsönzi az Awk, az alábbiak használhatóak:

Pl. az if használata:

$ echo '2.2'| awk '{ if ($1==1) {print "igaz"} else {print "hamis"}}'
hamis

Az Awk nyelv vezérlési utasításnak tekinti a next utasítást (tulajdonképpen függvényt) is.

A next végrehajtásakor az Awk abbahagyja a kurrens rekord feldolgozását, újat vesz a bemenetről és újraindítja vele az Awk programot. Pl. ha arra számítunk, hogy a bemenet minden sorában 4 mező van, és nem szeretnénk hibás feldolgozást végezni, akkor olyan sorok érkezésekor amelyekben nincs 4 mező könnyen kikerülhetjük ezeket:

#!/bin/awk -f 
{ 
    if (NF != 4) { 
        print "Rossz mezőszám, sorszám: " NR " : " $0 
        next 
    }   
} 
#... feldolgozások itt kezdődnek

Az Awk nyelvben használható függvényeknek 2 kategóriája van, a beépített és a felhasználó saját függvényei. A beépített függvények fontosabb csoportjai a numerikus, a sztring és a be/kimenetet vezérlő függvények.

$ echo '' | awk '{print sin(1)}'
0.841471

$ echo 'első második' | awk '{s=substr($2,5,3); \
s1=sprintf("%s%s", $1,s); s2=substr($2,0,4); print s1,s2}'
elsődik máso

function név (arg1, arg2, . . .)
{
    utasítások;
}

fuggvenynev (

function hatvany(i,j,hat) { 
    hat=i**j 
    return hat 
} 

x=hatvany(2,3)

név(kifejezés1, kifejezés2, … )

változó=név(kifejezés1, kifejezés2, … )

#!/usr/bin/awk -f 

BEGIN { 
    for (i=0; i < 10; i++) { 
        printf "%4d\t%4d\n", i,negyzet(i) 
    } 
    print "\na főprogramból látható negy:" negy
} 

function negyzet(i) { 
    negy=i*i 
    return negy 
} 

$ awk -f negyzet.awk
   0       0
   1       1
   2       4
   3       9
   4      16
   5      25
   6      36
   7      49
   8      64
   9      81

a főprogramból látható negy:81
$ 

Az awk parancsot is használhatjuk nagyon egyszerű, kis műveletekre vagy önálló, nagyobb programok készítésére, amelyeket héjprogramokból futtatunk és részfeladatokat oldunk meg velük.

Az awk használatára lemezpartíciók lefoglaltságának követését adjuk példaként.

A Unix rendszerek felcsatolt lemezpartícióinak méretét és elfoglaltságát a legegyszerűbben a df (disk free) paranccsal tudjuk kiírni, a méretek implicit 1 kilobyte-os egységekben vannak megadva:

$ df
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda2             25798712   3428312  21059900  14% /
udev                    896720       104    896616   1% /dev
/dev/sda1               108883     29450     73811  29% /boot
/dev/sda5            185778200  21664256 154676964  13% /home
/dev/sda6             24525480   8870072  14409572  39% /usr
$

A lista az eszköz fájl nevét, méretét valamint az elfoglalt és szabad 1 kilobyte-os blokkok számát írja ki. Az utolsó oszlop a fájlrendszerbe való csatolás helyét adja meg. A -h opciójával szemmel könnyebben olvasható listát készít:

$ df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/sda2              25G  3.3G   21G  14% /
udev                  876M  104K  876M   1% /dev
/dev/sda1             107M   29M   73M  29% /boot
/dev/sda5             178G   21G  148G  13% /home
/dev/sda6              24G  8.5G   14G  39% /usr

A lista mezői szóközökkel vannak elválasztva, ezek száma nem ugyanannyi minden mező közt, így az awk a legalkalmasabb arra, hogy az ehhez hasonló kimenetekből információt vágjon ki. Pl. ha szükségünk van a /home könyvtár alatti partíció méretére, akkor az az alábbi paranccsal kaphatjuk meg:

$ df | awk '/home/{print $2}'
185778200
$

, vagy a lefoglaltságra százalékban:

$ df | awk '/home/{print substr($5,1,length($5)-1)}'
13
$

Ezeket a számokat változóba lehet írni, és felhasználni számításokra:

$ used=$( df | awk '/home/{print substr($5,1,length($5)-1)}' )
$ echo A /home partíció $used százaléka foglalt
A /home partíció 13 százaléka foglalt
$

Az alábbi parancs összeadja a rendszeren létező partíciók méretét (1 kilobyte-os blokkokban):

$ df | awk 'NR!=1{s=s+$2}END {print s}'
237107995
$

A df opcióit, lehetőségeit lásd a kézikönyvében.

A következő szkript a partíciók lefoglaltságát ellenőrzi. A fájlrendszer partíciói az alábbi állapotban vannak:

$ df
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda2             25798712   3428400  21059812  15% /
udev                    896720       104    896616   1% /dev
/dev/sda1               108883     29450     73811  29% /boot
/dev/sda5            185778200  21664260 154676960  13% /home
/dev/sda6             24525480   8870072  14409572  39% /usr
$ 

A szkriptnek (dmonitor.sh) paraméterként megadjuk a partíciók csatolási pontját, és azt a százalékban maximális lefedettséget amit már problémának tekintünk. Ezt egy egyszerű felsorolásban adjuk meg a parancssoron. Ha a partíciók nincsenek megtelve, a szkript nem ír ki semmit, ha valamelyik meghaladja az kijelölt határt, a szkript üzenetet ír ki. Tehát:

$ bash dmonitor.sh /home 80
$ bash dmonitor.sh /home 80 / 60
$

nem kapunk üzenetet, mert sem a /home, sem a / nem haladta meg a 80% illetve 60% lefoglaltságot (a /home esetében a 80%-ot, / esetében a 60%-ot ellenőrizzük). Ha kis méreteket adunk meg az ellenőrzött százalékoknak (teszt miatt):

$ bash dmonitor.sh /home 12 / 60
Baj van a /home partícióval: lefoglaltság: 13 %

$ bash dmonitor.sh /home 12 / 12
Baj van a /home partícióval: lefoglaltság: 13 %
Baj van a / partícióval: lefoglaltság: 15 %

$

A szkript az alábbi:

#!/bin/bash
Az argumentumában magadott könyvtárakra csatolt
#lemez partíciók lefoglaltságát figyeli
#ha az lefoglaltság meghaladja a tesztelendő maximális
#lefoglaltságot, egy üzenetet ír ki, egyébként nem ír ki semmit
#Paraméterek:
#   $1 - csatolási pont neve, pl.: /home
#   $2 - maximális lefoglaltság, pl.: 90 (egész szám, jelentése 90%)
#
#   utána $3,$4 hasonló párt jelent, $5, $6 szintén, stb.
#

#ideiglenes fájl a df kimenetének felfogására
TEMPFILE="/tmp/df.tmp"

#a df kimenetét az ideiglenes fájlba írjuk
#hogy ne legyen szükséges többször meghívni
#előtte levágjuk az első sorát amire nincs szükségünk
df | tail -n +2 > $TEMPFILE

msg=""              #ebbe a változóba gyűjtjük a hibaüzeneteket

#kell legalabb 2 paraméter
if (( $# < 2 )) ;then
    echo dmonitor: hibás indítás, kevés paraméter
    exit 1
fi
#minden egyes könyvtár és százalék párosra elvégezzük az ellenőrzést
#amíg van még parancssori paraméter
while (( $# != 0 ))
do
    part="$1"       #első paraméter a partíció
    max="$2"        #második paraméter a maximális lefoglaltság
    shift 2         #eltoljuk két pozícióval a parancssort
                    #a következő ciklust készítjük elő ezzel

    #végzünk néhány ellenőrzést
    if [ -z "$part" ] ; then
        echo dmonitor: hibás bemenet, partíció helyett üres sztring!
        exit 1
    fi
    #a méret egy vagy kétjegyű egész szám?
    if ! [[ $max =~ ^[0-9]{1,2}$ ]] ; then
        echo dmonitor: a max=$max méret nem kétjegyű egész szám!
        exit 1
    fi

    #kiszűrjük a partíciónak megfelelő sort
    used=$( cat $TEMPFILE | \
        awk -v part="$part" '{if ($6==part) \
        print substr($5,1,length($5)-1)}' )

    if (( used > max )) ;then
        msg="$msg""Baj van a $part partícióval: $used % \n"
    fi

done

#ha van üzenet kiírjuk a kimenetre
#az echo -e kapcsolója a \n szekvenciát újsorrá alakítja
if [ -n "$msg" ] ; then
    echo -e "$msg"
fi

Megjegyzések:

Ez a szkript egyszerű megoldás, igazi élesben futó rendszereken általánosabb megoldást kell tervezni.

Folyamatnak (process) nevezzük az operációs rendszerben a futó program egy példányát.

Amikor egy operációs rendszer egy programot futtat, akkor a program kódján kívül egyéb információkat is nyilvántart erről. Így például a programhoz rendelt memóriaterületet, megnyitott állományokat, környezeti változóit és még sok egyebet. Ezeket is kezelnie kell, így a futó program példánya több információt jelent mint a programkód. A Unix rendszerek egyik legfontosabb feladata a folyamatok kezelése. Interaktív munka során a héj szintjén a felhasználónak több lehetősége van befolyásolni a futó folyamatokat.

A Unix rendszerek folyamatai "párhuzamosan" futnak, legalábbis ez így tűnik a felhasználó számára. A folyamatok párhuzamos végrehajtását a kernel egyik komponense, az ütemező (scheduler) vezérli, így a folyamatok felváltva jutnak rövid futási időhöz a processzoron (a kis időintervallum neve time slice), amennyiben egy processzoros rendszeren futnak. Ha a rendszer több processzoros, a kernel megpróbálja ezt is kihasználni a párhuzamosítás érdekében. Ugyanakkor ezeken a rendszereken több felhasználó dolgozhat egyidejűleg. A folyamatokat az ütemező bizonyos prioritások szerint kezeli, így a fontosabbak gyakrabban jutnak futási időhöz

Interaktív munka közben a programokat (pl. a Unix parancsokat) a héjból indítjuk, magát az indítás folyamatát mindig a kernel végzi. A kernel adatstruktúrákat hoz létre, amiben a folyamat dinamikus leíró információit tartja. A folyamatok egyenként rendelkeznek az alábbi tulajdonságokkal:

A folyamatlétrehozás gyorsan, kevés erőforrást használva történik a Unix rendszerek alatt. Ezért működik jól a Unixban az a stratégia, hogy a nagyobb feladatokat kis programok összekapcsolásával kell megoldani.

A folyamatok futásuk közben több állapotot vesznek fel. Erre azért van szükség, mert a kernel a folyamatokat felváltva engedi futni, hol megállítja és várakoztatja ("blokkolja") őket hol pedig egy adott időre teljesen felfüggeszti őket (pl. ha egy sleep parancsot hajtunk végre).

A folyamatokat a Unix ps nevű parancsának segítségével listázzuk (használatát lásd alább). Mivel a folyamatok ütemezése nagyon kis időintervallumok alatt történik (pl. az ütemezési idő 10 miliszekundum körüli is lehet), nem látható minden köztes állapot a terminállal történő listázás folyamán (ennek nincs is értelme, a terminálon megjelenő szöveg kiírása több ideig tarthat, mint jó néhány folyamat egymás utáni ütemezése). A folyamatok fontosabb, ps által listázható állapotai a UNIX/Linux rendszerek alatt az alábbiak (Linuxon, a GNU ps-t használva):

A folyamatok azonosítására a rendszer egy folyamatazonosítónak nevezett egész számot használ(process id vagy pid). Ezen keresztül érjük el a gyakorlatilag folyamatot illetve annak tulajdonságait. Azt mondjuk, hogy az 1562 számú, vagy csak 1562-es folyamat fut, függesztődik fel, kilép, stb.

Amikor a rendszer indul, és a kernel elkezdi felépíteni a rendszert, egy init nevű folyamat az első amit elindít. Ezt az ütemező indítja, amelyiket a legtöbb rendszeren 0 számú folyamatként tartunk számon (neve sched , swapper vagy egyszerűen csak kernel a különböző rendszereken, a ps parancs nem listázza ki). Az első valódi folyamat az init , amelynek azonosítója 1. A utána indított folyamatok mind tőle származnak, így a folyamatok összefüggésükben egy fa szerű struktúrát alkotnak. Ezt megjeleníthetjük a pstree paranccsal Linuxon: alább ennek kis részlete látszik (a zárójelben levő számok a folyamat azonosítót jelentik):

$ pstree -p 
init(1)─┬─acpid(2991) 
        ├─atd(3273) 
        ├─auditd(2368)─┬─audispd(2370)───{audispd}(2371) 
        │              └─{auditd}(2369) 
        ├─automount(2964)─┬─{automount}(2965) 
        │                 ├─{automount}(2966) 
        │                 ├─{automount}(2969) 
        │                 └─{automount}(2972) 
...

A héj a saját folyamatazonosítóját a $ speciális változójábanban tartalmazza, értékét a $$ hivatkozással érjük el. Az interaktív héj folyamatazonosítóját tehát így listázhatjuk:

$ echo $$ 
16239 
$ 

A terminállal való munka során egy parancssorral egyszerre akár több folyamatot indíthatunk. Pl. az alábbi parancssor:

$ head -20 data.txt | sort | uniq

3 folyamatot indít és köztük csővezetékeket hoz létre. Ezért a terminállal történő munka számára szükséges egy másik fogalom is, ami jellemzi az egy parancssorral indított folyamatokat.

Egy parancssor által kiadott "feladatot" nevezi a UNIX "job" -nak. Ezeket külön követni lehet a Unix jobs paranccsával.

A fontosabb fogalmakkal amelyek a feladatok kezeléséhez tartoznak már találkoztunk:

Az előtérben futtatott folyamatokat meg lehet szakítani a terminálról beütött megszakító karakterekkel, amelyek tulajdonképpen jelzéseket küldenek (lásd alább): Ctrl-C - megszakítás, Ctrl-Z - felfüggesztés, Ctrl-\ kilépés program memóriaképének kiírásával (core dump).

Ha a parancssoron elindítunk egy folyamatot a háttérben, az utolsó indított folyamat azonosítóját a ! speciális változóban találjuk és $! hivatkozással érjük el.

A folyamatok kezelésének illusztrálásához egy kis szkriptet fogunk használni, amelyik semmit sem végez, de alkalmas arra, hogy ciklusban hosszú ideig fusson periodikus várakozásokkal, így lesz időnk megfigyelni a történteket. A szkriptnek indításkor megadjuk egy paraméterben, hány másodpercig végezze a "semmit".

A lassu.sh szkriptünk kódja:

#!/bin/bash

if [ -z "$1" ];then
    echo használat: lassu.sh  másodperc
    exit 1
fi

n=$1                  #hány ciklust végez

while (( n-- ))
do
    sleep 1
done

Az alábbi példában a háttérben indítjuk a lassu.sh-t (pontosabban egy második bash értelmezőt, amelyik a lassu.sh-t értelmezi). Utána kilistázzuk az apa és fiú folyamat azonosítóit. Majd a pstree-vel az apa-fiú viszonyt (a pstree -p opciója a folyamat azonosítókat, a -a a folyamatot indító parancssort listázza). Ha a pstree-nek argumentumként egy folyamatazonosítót adunk, csak a kiválasztott folyamatot és a fiait listázza. Látható, hogy a sleep mint új folyamat jelenik meg a második bash alatt.

$ bash lassu.sh 200 &
[1] 12606
$ echo $!
12606
$ echo $$
23571
$ pstree -ap 23571
bash,23571
  ├─bash,12606 lassu.sh 200
  │   └─sleep,12735 1
  └─pstree,12737 -ap 23571
$
[1]+  Done                    bash lassu.sh 200
$

A szkriptet háttérben indítottuk: a []-ben található számot, amelyet a shell ír vissza "job" vagy feladat számnak nevezzük. A második szám (12606) a szkriptet futtató héj folyamatazonosítója. Észrevehető, hogy az indító héj ! változója ezt tartalmazza. Ugyanakkor a $ változó értéke egy másik azonosító, ez az általunk használt interaktív héjé. Ha 200 másodperc múlva egy újsort ütünk be, a héj kiírja a Done szót tartalmazó sorban, hogy véget ért a háttérben futó folyamat (az újsor leütése a kimeneti pufferben levő szöveget írja ki a terminálra). Az első háttérben indított feladat száma 1, ha több feladatot indítunk, ezek kis, növekvő egész számok lesznek (2,3,...).

A jobs parancs biztosítja a terminálról az elindított feladatok felügyeletét. Fontosabb opciói:

Az alábbi példában a lassu.sh szkript egymás után indított két példányán keresztül illusztráljuk használatát:

$ ./lassu.sh 500 &
[1] 18002
$ #a masodik az előterben, majd Ctrl-Z-vel felfüggesszük
$ ./lassu.sh 500

[2]+  Stopped                 ./lassu.sh 500
$ #kilistázzuk a futó feladatokat
$ jobs -l
[1]- 18002 Running                 ./lassu.sh 500 &
[2]+ 18108 Stopped                 ./lassu.sh 500
$ #kilistázzuk a futó feladatokat
$ #elindítjuk háttérben a másodikat is
$ bg 2
[2]+ ./lassu.sh 500 &
$ jobs -l
[1]- 18002 Running                 ./lassu.sh 500 &
[2]+ 18108 Running                 ./lassu.sh 500 &
$ #eloterbe hozzuk a kettest
$ fg 2
./lassu.sh 500
$ 

A "+" jel a job szám mellett az utolsó, a "-" jel az utolsó előtti indított folyamatot jelzi.

Ha egy szkriptből háttérben indítunk egy másikat, és az előtérben fut, a szkript következő parancsa csak akkor indul, ha az előző szkript véget ér, pl. az alábbi start.sh szkriptben:

#!/bin/bash
./lassu.sh 100
echo vége
exit 0

, de ha a lassu.sh-t háttérben indítjuk, az indító szkript hamarabb ér véget, mint pl. az alábbiban:

#!/bin/bash
./lassu.sh 100 &
echo vége
exit 0

A Unix rendszerekben futó folyamatok általában egy futó folyamat fiaként kell létezzenek, így az indító folyamatnak meg kell várnia fiát, ezt a wait paranccsal oldhatjuk meg. Használata:

wait               #minden fiú folyamatra vár
wait n             #az n azonosítójú folyamatra vár  
wait %n            #az n.-dik job folyamataira vár 

Az opcionális n szám folyamatazonosítót jelent, ha % jel van előtte akkor job (feladat) azonosítót.

A wait parancs az argumentumában megadott job számhoz (%n) tartozó folyamatokra (mindegyikre) vagy egy bizonyos folyamatra (n) vár, utána visszaadja annak kilépési kódját. Ha hiányzik a folyamatazonosító, akkor minden fiú folyamatra vár.

n helyett szerepelhet egy lista is: n1 n2 n3 … formában.

A wait végrehajtása alatt a shell nem indít új parancsot és nem olvassa a terminált sem.

Az alábbi programban kétszer indítjuk a lassu.sh szkriptet utána bevárjuk végrehajtásukat. A lassu.sh annyi másodpercig fut, amennyit kérünk tőle a parancssoron. Így az elsőnek indított példány hamarabb ér véget. A wait végrehajtásakor a program mindkettőt bevárja:

#!/bin/bash

./lassu.sh 3 &
./lassu.sh 10 &

wait

echo vége
exit 0

A ps (process status) parancs a folyamatok követésére használt legfontosabb parancs. Gyakorlatilag minden, a kernel által nyilvántartott információt ki lehet vele listázni a folyamatokról.

Opciói System V (- jel az opció előtt) vagy BSD (- jel nélkül) stílusúak is lehetnek; a ps komplex parancs és sok opcióval rendelkezik. A GNU változata több UNIX rendszer ps parancshasználati módját is tudja emulálni, lásd ezzel kapcsolatban a ps kézikönyv oldalát. Ezért csak néhány egyszerű használati módot fogunk átnézni.

A ps egy táblázatszerű kimenetben írja ki a folyamatok információit. Első sora jelzi az oszlopokban kiírt információkat. Kimenetének legfontosabb oszlopai:

Az alábbi táblázatban pedig megadjuk a ps néhány gyakran használt módját, a jobb oldali oszlopnban a ps ilyenkor használt opciói találhatóak.

$ ps
  PID TTY          TIME CMD
15304 pts/0    00:00:00 bash
15366 pts/0    00:00:00 cat
15715 pts/0    00:00:00 bash
15716 pts/0    00:00:00 sleep
16874 pts/0    00:00:00 ps

$ ps -C bash,lassu.sh
  PID TTY          TIME CMD
 1373 pts/0    00:00:00 bash
 2976 pts/1    00:00:00 bash
 3009 pts/2    00:00:00 bash
 6167 pts/0    00:00:00 lassu.sh

$ ps -H
  PID TTY          TIME CMD
15304 pts/0    00:00:00 bash
15366 pts/0    00:00:00   cat
15715 pts/0    00:00:00   bash
15716 pts/0    00:00:00     sleep
17582 pts/0    00:00:00   ps

$ ps -o pid,comm
  PID COMMAND
 1373 bash
 6167 silent.sh
 7721 sleep
 7722 ps

$ cat > a.txt & 
[4] 9616 
$ ps  -p 9616 
  PID TTY          TIME CMD 
 9616 pts/0    00:00:00 cat  

Dinamikusan a top paranccsal listázhatjuk a folyamatokat. A ps csak egy adott időpillanatban létező állapotot mutat. A top alkalmas a kiugróan sok erőforrást használó folyamatok listázására (processzoridő, memória). A top parancsai:

A top több parancssori argumentummal is rendelkezik, részletesen lásd a parancs kézikönyv oldalait.

Folyamatok futási prioritását parancssori indításkor a paranccsal módosíthatjuk, illetve a renice-al változtathatjuk. A folyamatok egy un. nice számmal rendelkeznek: ez nem a pontos prioritást adja meg, de információt jelent az ütemezőnek, és ez figyelembe is veszi. A folyamatok nice száma -20 -tól (legnagyobb prioritás) egészen 19-ig (legkisebb) terjed. A nice -n paranccsal n-et adunk az implicit nice számhoz. Argumentum nélkül a nice kilistázza az implicit nice számot. Az alábbi program pl. a legkisebb nice számmal fog futni:

$ nice -n 19 job.sh

A folyamatok normális esetben lefutnak és ha elvégezték feladataikat és befejeződnek, amennyiben shell szkriptek az exit paranccsal kilépnek (a C programozási nyelven írt programok a C exit() függvényével lépnek ki). Futás közben többféleképpen kommunikálnak egymással: vagy adatokat küldenek át egyik folyamatól a másikhoz (pl. állományokon vagy csővezetéken keresztül) vagy egyszerűen csak egymás feladatának összehangolása végett szinkronizációs információkat küldenek.

Az folyamatok közti kommunikáció egyik formája az aszinkron kommunikáció. Aszinkron üzenetnek azokat az üzeneteket nevezzük, amelyek bármely pillanatban elküldhetőek egy folyamathoz, függetlenül attól, hogy az mit végez: vár-e éppen erre, vagy nem. Az aszinkron üzenetek egyik formája a jelzések általi kommunikáció.

A jelzés (signal) egy aszinkron értesítés amelyet egyik folyamat küld a másiknak (vagy a kernel egy folyamatnak) valamilyen esemény bekövetkeztéről. A folyamatok jelzéseket kiszolgáló függvényeket, un. jelzés kezelőket (signal handler) definiálhatnak. Amikor a folyamathoz egy jelzés érkezik, akkor normális futása megszakad, és a jelzéskezelő indul el. Amennyiben a folyamat nem definiált kezelő függvényt, a jelzés implicit kezelője szolgálja ki azt.

A jelzésekre egy rövid nagybetűs névvel (pl. INT ) vagy egy egész számmal (pl. 2 -es jelzés) hivatkozunk. Bizonyos esetekben, pl. a C nyelv fejléc állományaiban vagy a kill -l parancs listázásakor a név elé kerül a SIG szócska, tehát így találkozunk velük: SIGINT.

A legtöbb jelzésnek van egy implicit kezelési sémája. Van két olyan jelzés, amelyre a folyamatok nem definiálhatnak kiszolgáló függvényt (KILL és TSTP, lásd alább).

A Unix rendszerek nem egyformán definiálják a rendszerben lehetséges jelzéseket, illetve a hozzájuk rendelt azonosítókat. Az alábbi jelzések minden rendszeren megvannak, és a héj programozás példáihoz elegendőek. A felsorolt jelzések kiszolgálójánál nem kötelező az alábbi előírásokat implementálni. Ezek inkább ajánlások, és a legtöbb program ezeket implementálja. De elvileg, a jelzés megérkezése után a jelzést kiszolgáló függvény bármit implementálhat.

Látható, hogy a legtöbb jelzés valamilyen rendkívüli, bármikor előforduló eseményhez kapcsolódik, és implicit következményük a folyamat leállítása. Hirtelen leálláskor, ha a folyamat pl. ideiglenes állományokkal dolgozik, fontos lehet a "takarítás", pl. a már nem szüksége állományok törlése. Sok jelzés hagy erre időt, tehát írható jelzéskezelő, amely elvégzi ezt a feladatot.

Jelzést a kill paranccsal küldhetünk. Használata:

ahol az n egy egész szám, a jelzés száma. Helyette használhatjuk a jelzés nevét is:

Használatos még:

alakban. Mindhárom alak a megadott jelzést küldi a folyamatazonosítóval rendelkező folyamatnak vagy folyamatoknak. A fenti alakokon kívül, a folyamatazonosító speciális értékeire (0, -1, -n) folyamat csoportoknak is küldhető jelzés (lásd a kill kézikönyvét).

A jelzések neveit és azonosítóit a kill -l paranccsal listázhatjuk ki. A -p opciója csak kilistázza azokat a folyamatokat amelyeknek jelzést küldene, de nem küldi el a jelzést (tesztelésre használjuk).

Jelzést csak azoknak a folyamatoknak küldhetünk, amelyekre az engedélyezve van (jogrendszer). Futást módosító jelzéseket csak saját nevünk alatt futó programnak küldhetünk (kivétel természetesen root, ő minden programnak küldhet).

A kill igaz értékkel tér vissza ha a jelzést sikerült elküldeni, egyébként hamissal (1).

Terminálról billentyűkkel 3 fontosabb jelzést küldhetünk a folyamatoknak: az INT azonnal megszakítja a folyamatot, a TSTP (terminal stop) felfüggeszti és a QUIT szintén leállásra szólítja fel, időt hagyva "tisztogatás"-ra. Mindhárom jelzés kezelhető a folyamat által (tehát a folyamat futtathat más kódot is mint az implicit viselkedés).