OPERÁCIÓS RENDSZEREK

A UNIX OPERÁCIÓS RENDSZER 
A Unix egy többfelhasználós-többfeladatos rendszer (multiuser- multitasking). A többfelhasználós működés azt jelenti, hogy egyszerre több felhasználó is dolgozhat egy adott gépen. A többfeladatos működés azt jelenti, hogy a gép egyszerre több programot tud futtatni (a felhasználó szempontjából). Egyprocesszoros rendszerekben ez csak virtuálisan jelent párhuzamos futtatást, többprocesszoros rendszerek eseten lehetséges, hogy az egyes processzorok más-más feladatot végezzenek. 
  
A UNIX RENDSZER FELÉPÍTÉSE 

 ALKALMAZÁSOK	
      SEGÉDPROGRAMOK                  SHELLEK	
KERNEL	
 HARDVER	
A UNIX réteges felépítésű. A legbelső rész a kernel az operációs rendszer magja, amely a rendszer erőforrásainak szétosztását és a futó folyamatok ütemezését végzi. 
A kernelre épülnek a UNIX rendszer különböző programjai (ls, cat, ...) Ezek között a legfontosabb a különböző parancsértelmezők (shell, "burok" ) 
A parancsértelmező a felhasználó belepésekor indul el, értelmezi és végrehajtja a begépelt parancsokat, kezeli a ki és bemenetet. Ezen kívül egy programozási nyelv is. 
  
FOLYAMATKEZELÉS 
A program egy futtatható fájl (akár egy gépi kódot tartalmazó bináris fájl akár a shell által értelmezhető parancsokból álló fájl). Valahányszor egy programot elindítunk, egy új folyamat (process) jön létre. Egyszerűsítve, a folyamat egy programnak egy futó példánya, a saját külön adatterületével. A parancsok (pontosabban a parancsok elindításával létrehozott folyamatok) végrehajtása szekvenciálisan történik. Tehát, ha egy felhasználó elindít egy parancsot, addig nem kapja vissza a parancs promptot, amíg az éppen futó folyamat be nem fejezőődött. Egy háttérfolyamat (background process) elindítása eseten rögtön megjelenik a parancs prompt és lehetőség van újabb parancs végrehajtására. A háttérfolyamatok egy speciális típusa a démon (daemon) folyamat. Ez egy olyan folyamat, amit a rendszer általában automatikusan indít el és valamilyen felügyeleti szerepet ellátva állandóan fut a háttérben. (pl. nyomtatási kérelmek besorolása és végrehajtása). Ha nincs bejelentkezett felhasználó, akkor is több démon folyamat fut, biztosítva a rendszer folyamatos működését. 
Ha háttérben indítunk el egy folyamatot, 
$ parancs & 
1514 
$ 
A 1514 a folyamat azonosítója (Process-id, ID). Ezt később a folyamatra való hivatkozásra lehet használni. 
Folyamatok lelövése: 
$ kill 1514 
Futó folyamatok kilistázása 
$ ps 
  
FÁJLRENDSZER 
A UNIX legfontosabb alapfogalma a fájl: egy struktúrálatlan byte-sorozat. A DOS-szal összehasonlítva, a Unix fájlrendszere sokkal egységesebb: felfogása szerint "minden file". Ez azt jelenti, hogy a felhasználó fájljai, a rendszer könyvtárkatalógusai és a rendszerhez csatlakoztatott hardver eszközök mint fajlok egységesen kezelhetoek. 
A fájlnevek maximális hossza általában 255 karakter. A kisbetűk és nagybetűk különböznek, szinte minden karakter használható. Azok a fájlok amelyeknek a neve pont karakterrel kezdődik rejtett fájlok. Ezek általában adminisztrációs és konfigurációs információkat tartalmaznak. Minden fájlnak van tulajdonosa és minden felhasználó egy csoport tagja. A fájlokhoz olvasási, írási, végrehajtási jogok tartoznak, melyek beállíthatók a tulajdonos, a csoportja és mindenki más számára. 
A Unix hierarchikus felépítésű, a fájlok könyvtarakban vannak tárolva. Egy könyvtárból alkönyvtárak nyílhatnak, amelyek ugyancsak tartalmazhatnak további fájlokat és alkönyvtárakat, és így tovább. 
A Unix fájlrendszerben három kitüntetett pont létezik az egyes felhasználó szamara: 
•	a gyökérkatalógus (root directory), ez a fájlrendszer kezdőpontja    / 
•	az alapkatalógus (home directory), az egyes felhasználóhoz tartozó kiindulási pont     ~/ 
•	a munkakatalógus (current directory), az a pont, ahol a felhasználó éppen tartózkodik a fájlrendszerben   ./ 
Általános könyvtárnevek: 
../              Az aktuális fölötti könyvtár 
/bin             A bináris programok könyvtára 
/dev             A különféle eszközök könyvtára 
/etc             Egyéb rendszerfájlok, rendszerint a rendszeradminisztrációs fájlok. 
                 A legtöbb esetben itt van a jelszavakat tároló fájl is. 
/mnt             Az ideiglenesen "felakasztott" eszközök becsatolási pontja (lásd mount utasítás) 
/usr             Felhasználói programok, forrásszövegek, könyvtárak 
/lib             Fontosabb függvénykönyvtárak - ezeket csak a programozók használják. 
/usr/bin         Végrehajtható programok (főként segédprogramok) 
/usr/lib         Utasításkönyvtárak programozóknak 
/usr/src         Forrásnyelvű szövegek 
/usr/local       Helyileg telepített programok és tartozékai, egyébb nyilvános dolgok 
/usr/local/bin   Helyileg telepített futtathatók 
/usr/man         Az online dokumentáció, amelyet a man paranccsal tudunk megjeleníteni. 
  
Könyvtárkezelő utasítások: 
•	A munkakönyvtár nevének kiírása: pwd 
•	A munkakönyvtár változtatása: cd 
•	A könyvtár átnevezése: mv 
•	A könyvtár tartalomjegyzéke: ls 
•	A könyvtár létrehozása: mkdir 
•	A könyvtár letörlése: rmdir 

Fájlkezelő parancsok: 
•	Fájlok létrehozása 
o	szövegszerkesztővel 
o	átirányítással 
$ cat >fnev 
szoveg... 
szoveg... 
......... 
CTRL-D 
$ 
 
•	Fájlok átnevezése: mv (move) 
•	Fájlok másolása: cp (copy) 
•	Fájlok törlése: rm (remove) 
•	Fájlok kiírása: cat 
•	Fájl láncolása könyvtárhoz: ln 
•	Fájl-jogok beállítása: chmod 
On-line help 
Sok Unix parancsot ha paraméter nélkül, rossz paraméterezéssel vagy a -? opcióval hívunk meg, kiír egy tömör üzenetet az adott parancs használatáról. Másik lehetőség a man parancs, melynek hatására a kérdéses utasítás részletes leírását kapjuk. 
  
A STANDARD PERIFÉRIÁK ÉS ÁTIRÁNYÍTÁSUK 
A Unixban 3 standard be- és kimeneti csatorna van definiálva: 
•	standard bemenet (stdin, 0) 
•	standard kimenet (stdout, 1) 
•	standard hibacsatorna (stderr, 2) 

Alapértelmezésben a standard bemenet a billentyűzet, a kimenet és a hibacsatorna pedig a képernyő. Az átiranyítás (redirection) lényege, hogy a programot utasíthassunk arra, hogy a bemenetet ne a billentyűzetről varja, illetve eredményeit ne a képernyőre írja ki. 
•	a bemenet átirányítása  < 
•	a kimenet átirányítása   > 
•	adaptív átirányítás        >>   az átirányított adatok a meglévőkhöz fűződnek 

A CSŐVEZETÉK (PIPE) 
A pipe egyik program kimenetet a másik program bemenetével köti össze. 
Jele   | 
pl. 
$ who | sort 
Csövek elágaztatása 
A tee parancs segítségével lehet elérni. A tee bemenetet a standard inputról veszi, kimenetet két helyre küldi: egyrészt a standard kimenetre, másrészt a paraméterként megnevezett állományba. 
pl. 
$ date | tee temp 
   Tue Feb 10 09:36:38 MET DST 1999 
$ cat temp 
   Tue Feb 10 09:36:38 MET DST 1999 
$ ls | tee tart | wc -l 
   5 
$ cat tart 
   Mailbox Tomogr Unix mail nsmail 
$ 

METAKARAKTEREK SEMLEGESÍTÍSE 
A metakarakterek semlegesítése által elérjük, hogy a shell “rendes” karakterekként kezelje őket és ne értelmezze őket. 3 módon tehetjük ezt meg: 
$ echo '***' 
*** 
$ echo "***" 
*** 
$ echo \*\*\* 
*** 
Mindhárom esetben a képernyőn megjelenik a *** 
  
MEGJEGYZÉSEK 
A # utáni karaktersorozatot a Unix megjegyzésként értelmezi. Vigyázat a szóközre! 
$ echo hello #hello! 
hello 
$ echo hello#hello! 
hello#hello! 
  
A UNIX LEMEZ BELSŐ SZERKEZETE 
A nulladik blokk (BOOT) a lemez első szektora, innen töltődik be az operációs rendszer. 
Az első blokk (SUPERBLOCK) tartalmazza a fájlrendszer adatait, a belső táblák adatait. 
Az inode tábla. Az inode név az index-node rövidítése, arra utal, hogy a fájlrendszerben az állományok jellemzőit tartalmazó inode-okat a rendszerprogramok indexkent használjak. 
Az inode tartalmazza az adott fájlra vonatkozó összes lényeges információt: 
•	az állomány méretét 
•	típusát 
•	tulajdonosát 
•	csoportját 
•	a hozzáférési jogokat 
•	az állományt alkotó lemezblokkok fizikai elhelyezkedését a lemezen 
•	a láncszámot 
•	hogy fájlról vagy katalógusról van szó 
•	az utolsó módosítás időpontját... 

Nem tartalmazza a szóban forgó állomány nevét, ezt a katalógusfájl tartalmazza. Minden katalógushoz tartozik egy fájl. Ebben a katalógusfájlban minden fájlhoz tartozik egy rekord, ami a fájl inode számát és a nevét tartalmazza. 

LÁNCOK LÉTREHOZÁSA 
A fájlrendszer egyik sajátossága a láncolás (link). Ez a mechanizmus arra szolgál, hogy egy adott állományt több néven is el lehessen érni. 
A Unix rendszer kétféle láncolási eljárást ismer, a merev és a lágy láncolást (hard and soft link). A merev láncolás legfőbb jellemzője, hogy a láncolt fájl teljesen egyenérékű az eredetivel. 
Ha például van egy állományunk text néven, akkor az ln parancs segítségével elérhetjük, hogy mondjuk szöveg néven is hivatkozhassunk rá. 
$ ln text szöveg 
Ekkor a láncolt állományok láncszáma (link count) egyel nagyobb értek. 
A láncolás mechanizmusa 
Amikor egy fájlt linkelünk, a megfelelő katalógusba egy új bejegyzést hozunk létre, ami egy már létező és más néven már hivatkozott inode-ra mutat. Az inode táblában növeljük a láncszámot. Tehát a fájlhoz magához nem nyúlunk. Láncolt fájl törlésekor töröljük az adott névhez tartozó bejegyzést a megfelelő katalógusfájlban és az inode táblában a megfelelő rekordban eggyel csökkentjük a láncszámot. Ha a láncszám 1, akkor töröljük a fájlt és a hozza tartozó bejegyzést az inode táblában illetve a katalógusfájlban. 
A szimbolikus lánc vagy lágy lánc 
Lényege, hogy a szimbolikus link katalógus bejegyzése nem az inode-jára mutat, hanem egy olyan különleges fájlra, ami a láncolt fájl nevét tartalmazza. A munkakatalógusból a következő utasítást kiadva: 
$ ln -s /usr/lib/sendmail.cf sendmail.cf 
ott egy sendmail.cf fájl keletkezik. Ekkor a láncszám nem változik, a fájl típusnál egy l van. A fájl nevénél a következő van: 
sendmail.cf -> /usr/lib/sendmail.cf 
Ha olvasni akarjuk a fájlt, akkor az előzőekben leírt módon eljutunk a /users/demo katalógusfájl sendmail.cf bejegyzéséhez, észrevesszük, hogy egy szimbolikus linkről van szó, az operációs rendszer ekkor megnyitja azt a bizonyos fájlt, ami a láncolt fájl nevet tartalmazza, ami itt a /usr/lib/sendmail.cf . Ezt a már ismert módon megkeresi és megnyitja. 
  
MOUNTOLÁS 
Mountolásnak (csatolásnak) nevezzük azt a tevékenységet, amikor egy különálló fájlrendszert becsatolunk egy már meglévőhöz. (pl. egy floppyn levő fájlrendszert) Ennek létezik az ellentétes művelete is, amikor egy előzőleg már csatolt fájlt lecsatolunk. 
  
SHELL SCRIPTEK 
Legyen egy egyszerű Shell script, amelyik a munkakatalógusban levő fájlok (állományok és könyvtárak) számát írja ki: 
$ cat >nf 
ls | wc -w 
CTRL-D 
$ 
Az nf állomány elkészülte után a futtatást többféle módon is intézhetjük. Az első megoldás azon alapul, hogy a shell is futtatható úgy, hogy a paraméterként átadott fájl tartalmat olvassa be és próbálja meg végrehajtani: 
$ sh nf 
12 
$ 
A második megoldás az, hogy a shellt egy “közönséges” programnak tekintjük, és átirányítjuk a bemenetet: 
$ sh <nf 
12 
$ 
A harmadik megoldás azon alapul, hogy a Unix shell minden olyan állományt, amelyik nem bináris állomány, de végrehajtható (a megfelelő hozzáférési jog engedélyezett), úgynevezett shell fájlnak (shell script) tekint, a benne levő szöveget pedig végrehajtható parancsoknak, és aszerint próbálja meg végrehajtani. 
$ chmod +x nf 
$ nf 
12 
$ 
  
PROGRAMARGUMENTUMOK 
A shell-változók két fajtáját különböztetjük meg, egyik a hagyományos programozási nyelvekben megszokotthoz változó, a másik úgynevezett pozicionális paraméter. A “közönséges” shell-változóknak akár parancsszinten, akár egy programban értékeket lehet adni, azt le lehet kérdezni, illetve módosítani. A pozicionális paraméterek azok az argumentumok, amelyeket végrehajtáskor átad a shell a meghívott shell scriptnek. Ellentétben a közönséges shell változókkal, a pozicionális paraméterek érteket a felhasználó soha nem változtathatja meg. 
$ parancs arg1 arg2 arg3 
    $0     $1   $2   $3 
Alakítsuk át az előbbi programot, hogy bármilyen könyvtárban meg tudja 
számolni az állományokat: 
$ cat >nf1 
ls $1 | wc -w 
CTRL-D                       # létrehoztam az nf1 állományt 
$ chmod +x nf1               # futtathatóva teszem 
$ nf1 /users/bin             # meghíváskor meg kell adni a könyvtárat 
$ 
  
PARANCSBEHELYETTESÍTÉS 
Lényege, hogy egy program eredményét nem a kimenetre küldi, hanem egy másik program paraméterlistájába illeszti. A parancsbehelyettesítéshez a behelyettesítendő parancsot `prog...` formában kell megadni. 
pl. 
$ echo Jelenleg `who | wc -l` felhasználó van bejelentkezve. 
Jelenleg 14 felhasználó van bejelentkezve. 
$ 
REGULÁRIS KIFEJEZÉSEK 
A Unix eszközök közül nagyon sok használ mintaillesztést, s a megadott mintára illeszkedő adatokon további feldolgozást hajt végre. 
Vannak olyan parancsok, ahol a felhasználó adja meg a keresendő mintát, ilyen a grep parancs, másokban rejtve dolgozik a mintakereső 
algoritmus. Reguláris kifejezések használatakor egy komplex mintát adunk meg (ez a reguláris kifejezés), és azt vizsgáljuk, hogy a 
feldolgozandó adatok melyik része illeszkedik a megadott mintára. A reguláris kifejezések karakterekből állnak, ezek közül néhány 
speciális jelentest hordoz, ezeket metakaraktereknek nevezzük. 
A reguláris kifejezéseket meghatározó szabályok: 
•	Egy egyedülálló karakter, amely nem újsor karakter, és nem a . * [ ] \ ^ $ karakterek egyike, önmagára illeszkedik. Ez azt jelenti, hogy ha a reguláris kifejezés egy a betű, akkor ez a vizsgált szövegben csakis egy darab a karakterre fog illeszkedni. 
•	A \c karakterpáros, ahol c egy látható karakter, a c karakterre illeszkedik a karakter literális értelmében. Tehet a \* illeszkedik a * -ra, a \\ pedig a \ -re. 
•	A . (pont) karakter egy olyan reguláris kifejezés, amelyik bármelyik (nem újsor) karakterre illeszkedik. Így pl. az ab. minta illeszkedik az aba, abb, abc, ..., abz, ab0, ... karaktersorokra. 
•	Ha e egy reguláris kifejezés, akkor e* egy olyan reguláris kifejezés, amely az e reguláris kifejezés 0 vagy többszöri előfordulását jelzi. Így az a* reguláris kifejezés illeszkedni fog az üres sztringre (hiszen abban zérószor szerepel az a karakter), valamint az a, aa, aaa, ...  karakterláncokra. 
•	A [ ] zárójelbe tett karaktersorozat illeszkedik az abban a pozícióban levő bármely, a zárójelben felsorolt karakterre. A karakterek felsorolására vonatkozó szabályok: 
o	kódjukat tekintve az egymás után következő karaktereket rovidíteni lehet a kötőjel használatával. Pl. 0-9a-z jelenti az összes számjegyet és az angol abc összes kisbetűjét. 
o	a nyitó zárójelet követő ^ jel a felsorolt karakterek tagadása. Pl. [^0-9] jelenti a bármely nem szám karaktert. 
o	a ] zárójel csak a felsorolás első tagja lehet 
o	a - karaktert a \- karakterpáros jelenti 
•	Két egymás után írt reguláris kifejezés szintén reguláris kifejezés. pl. [^0-9][0-9] kifejezés a nem szám karaktert követő szám karaktersorra illeszkedik. 
•	Két egymástól | jellel elválasztott reguláris kifejezés illeszkedik akar az egyik akar a másik kifejezésre. 
•	A ^ jel a sor elejére, a $ jel a sor végére illeszti a mintát. 
 
Példák: 
d[0-9][^0-9] 
[a-z[|\. 
[]ab] 
^[0-9] 
^[^0-9]*$ 

SZŰRŐK 
  
1. grep 
Arra szolgál, hogy egy adott minta előfordulását keresse a paraméterként megadott állományokban. 
Általános formája: 
$ grep mit_keressen hol_keressen 
  
Példák. 
$ grep '[tf]arka' fajl 
- kiírja a fal nevű állomány azon sorait, amelyekben a tarka vagy farka szavak szerepelnek 
$ grep '^\^' kalap 
- kiírja az összes olyan sort a kalap nevű állományból, amely ^ karakterrel kezdődik 
$ ls -l | grep ^d 
- kiírja a munkakönyvtárban levő összes katalógust 
$ grep '^main' *.c 
- kiírja a .c végű állományok azon sorait, amelyek a main karaktersorral kezdődnek 
  
2. egrep 
Lehetőség van arra, hogy a mintát egy állományból vegyük. Akkor érdemes ezt a lehetőséget használni, ha bonyolult mintát kell gyakran használni. 
Példa. 
$ cat >pattern 
'[A-Z].*[\.!\?]$' 
CTRL-D 
$ egrep -f pattern fal 
  
3. fgrep 
karakterláncot párhuzamosan keres 
  
4. sort 
Bemenetet soronként ASCII kódok szerint rendezi. 
-f a kis és nagybetűk megkülönböztetése nélkül rendez 
-d szótári rend 
-r minden összehasonlítás értelmét az ellenkezőjére fordítja 
-u az egymás után következő egyforma sorok közül csak egyet hagy 

5. AZ awk MINTAKERESŐ ÉS FELDOLGOZÓ NYELV 
  
HASZNÁLATA: 
$ awk 'program' fájlnevek 
  
A program szerkezete: 
minta {tevékenység} 
minta {tevékenység} 
Az awk a fájlnevekben levő bemenetet soronként beolvassa. Minden sort minden mintával összehasonlít. A sorral egyező mintára végrehajtja a hozza tartozó tevékenységet. Nem változtatja meg a bemeneti fájlokat. A minta is, a tevékenység is opcionális. Ha a tevékenységet elhagyjuk, az alapértelmezés szerinti tevékenység az egyező sorok kiírása. 
pl. 
$ awk '/^a/ {print}' file 
- kiírja a file nevű állomány minden olyan sorát, amelyik a-val kezdődik 
$ awk '/^a/' file 
- az eredmény ugyan az 
  
MEZŐK 
Az awk minden bemenő sort automatikusan mezőkre, azaz alapértelmezés szerint szóközökkel vagy tabulátorokkal elválasztott karakterláncokra oszt. Az awk a mezoőket $1, $2, ..., $NF nevekkel jelöli. $0 a teljes sor, változtatás nélkül. NF a mezők száma. 
pl. 
$ who | awk '{print $1, $5}' 
A mezőelválasztó karaktert meg lehet változtatni a -F parancsopcióval. 
pl. 
$ who | awk -F: '{print S1}' 
  
KIÍRÁS 
Az awk a bemeneti mezők számán kívül más mennyiségeket is nyomom követ. Az NR beépített változó az aktuális bemeneti rekord vagy sor sorszamat adja meg. 
$ awk '{print NR, $0}' 
- kiírja a teljes sort és előtte a sor sorszamat 
A print utasításban a vesszőkkel elválasztott tételek a kimeneti mezőelválasztó karakter, alapértelmezésben szóköz által elválasztva kerülnek kiírásra. A C nyelvből ismert printf utasítással tetszés szerint vezérelhetjük a kimenetet. 
  
MINTÁK 
A minták lehetnek reguláris kifejezések. Ezen kívül más módon is megadhatunk egy mintát: 
pl. 
$2 == "a"        - a második mező az a karaktert tartalmazza 
$2 ~ /./         - a második mező bármilyen karaktert tartalmazhat 
$2 !~ /^a/       - a második mező nem kezdődhet az a karakterrel 
length ($2) == 1  - a második mező hossza 1 
A ~ jel a reguláris kifejezés egyezését, a !~ jel pedig a különbözőséget jelzi. 
A minta a ! jellel tagadható: 
!($2== "a") 
pl. 
Adott a /etc/passwd állomány. 
1. Írjuk ki minden felhasználó azonosítóját és nevet; 
2. Írjuk ki azokat a felhasználókat, akiknek az azonosítójuk 4 karakterből áll. 
$ awk -F: '{print $1, $5}' /etc/passwd 
$ awk -F: 'length($1)==4 {print $1, $5}' /etc/passwd 
  
A BEGIN ÉS END MINTÁK 
A BEGIN tevékenységeket az awk parancs az első bemenő sor beolvasása előtt hajtja végre; a BEGIN-t változók inicializálására, fejléc nyomtatására, vagy az FS változónak érteket adva a mezőelválasztó kijelölésére használjuk. 
Az END tevékenységet az awk a bemenet utolsó sorának feldolgozása után hajtja végre. 
  
ARITMETIKA ÉS VÁLTOZÓK 
Az awk rendelkezik olyan függvényekkel, amelyek a bemenő adatokkal matematikai műveleteket végeznek. 
pl 
Adott az abc nevű fájl: 
123 234 345 sdghnfg 
876 756 98 kjhk 
12 23 435 rthjft 
Adjuk össze az első 3 oszlopban levő számokat: 
awk '{ s1 = s1 + $1 
       s2 = s2 + $2 
       s3 = s3 + $3 } 
     END {print s1, s2, s3}' abc 
A változókat nem szukaeges deklarálni, alapértelmezés szerint kezdeti értékük 0 illetve üres karaktersor. 

AZ awk BEÉPÍTETT VÁLTOZÓI 
  
FILENAME - az aktuális bemeneti fájl 
FS       - mezőelválasztó karakter, alapértelmezés szerint szóköz és tabulátor 
NF       - a bemeneti rekord mezőszáma 
NR       - a bemeneti rekordok száma 
OFMT     - a kimenő számok formátuma ( alapértelemezés: %g ) 
OFS      - kimenő mezőelválasztó karakter ( alapértelmezés: szóköz ) 
ORS      - kimeneti rekordelválasztó karakterlánc ( alapért: újsor ) 
RS       - bemeneti rekordelválasztó karakter (alapért: újsor ) 

AZ awk OPERÁTOROK (NÖVEKVÕ PRECEDENCIARENDBEN) 
= += -= *= /= %=        - értékadás 
||                      - VAGY 
&&                      - ÉS 
!                       - a kifejezés értekének tagadása 
> >= < <= == != ~ !~    - relációs operatorok, a ~ egyezés, a !~ nemegyezés 
semmi                   - karakterlánc-összekapcsolás 
+ -                     - összeadás, kivonás 
* / %                   - szorzás, osztás, maradék 
++ --                   - növelés, csökkentés 
  
AZ awk BEÉPÍTETT FÜGGVÉNYEI 
cos(kif)                - a kif koszinusa 
exp(kif)                - a kif exponenciálisa 
getline()               - a következő bemenő sort olvassa, 0-át ad vissza, ha fájlvége, 1-et, ha nem 
index(s1, s2)           - az s2 helyzete az s1 karakterláncban, 0-at ad vissza, ha nincs benne 
int(kif)                - a kif egész része 
length(s)               - az s karakterlánc hossza 
log(kif)                - a kif természetes logaritmusa 
sin(kif)                - a kif szinusza 
split(s,a,c)            - az s-t c karakter szerint a[1] ... a[n] mezőkre bontja, visszaadja n-et 
sprintf(fmt, ...)       - ...-ot az fmt szerint formázza 
substr(s, m, n)         - az s karakterlánc m-edik karakterénél kezdődő n karakteres része 

VEZÉRLÉS ELLENÕRZÉS 
  
Az if utasítás: 
if (feltétel) 
  utasítás1 
else 
  utasítás2 
Az else ág elmaradhat. 
  
A for utasítás: 
for (kif1; feltétel; kif2) 
  utasítás 
  
A while utasítás: 
while (feltétel) 
  utasítás 
  
A do utasítás: 
do 
  utasítás 
while (feltétel) 
  
A break utasítás az őt közrefogó while vagy do ciklusból törtenő azonnali kilépést okoz. 
  
A next utasítás hatására beolvassa a következő sort és az awk program újra elölről kezdi a minta egyezessenek vizsgálatát. 
  
Az exit utasítás hatására a vezérlés azonnal az END mintára kerül. 

TÖMBÖK 
A tömböket, ugyanúgy mint a változókat nem kell előre deklarálni, egy tömb méretét csak a gépben elérhető tárterület korlátozza. 
pl. 
a bemenetet fordított sorrendben írja ki: 
awk '{line[NR] = $0} 
END { for (i=NR; i>0; i--) print line[i]}' $* 
Megjegyzés: a shell szamara a $* a parancssor összes argumentumát jelenti. 
  
TÁRSTÖMBÖK ( ASSOCIATIVE ARRAY ) 
Adatfeldolgozásban gyakori feladat a név-értek jellegű adatpárok értékeinek összegzése. 
Például az 
Aladar   400 
Bela     200 
Aladar   100 
Cecilia  300 
Bela     700 
bemenetből ki akarjuk számolni a nevekhez tartozó összegeket: 
Aladar   500 
Bela     900 
Cecilia  300 
Az awk erre egy érdekes módszert ad, a társtömböket. Rendszerint úgy gondoljuk, hogy egy tömb indexe csak egész szám lehet, az awk-ban azonban bármilyen érteket használhatunk tömbindexként. 
Ebben az esetben a for utasítás szintakszisa: 
for ( változó in tömb ) utasítás 
Így az előbbi feladat megoldása, feltételezvén, hogy a feldolgozandó állomány neve adatok: 
awk ' 
{sum[$1]+=$2} 
END {for (name in sum) print name, sum[name] } 
' adatok 

FELADATOK 
1. Írjuk ki a rendszeridőt a következő módon: 
xx óra yy perc zz másodperc 
date | awk '{print $4}' | awk -F: '{print $1, "óra", $2, "perc", $3, "másodperc"}' 
(természetesen egy sorba írva) 
2. Írjuk ki n állomány tartalmat (ahol n természetes szám) úgy, hogy az egyes állományok sorai fordított sorrendben jelenjenek meg. 
awk ' { line[NR] = $0 } 
END { for (i=NR; i>0; i--) print line[i] } ' $* 
3. Adott n állomány, (n természetes szám). Írjuk ki az állományok tartalmat úgy, hogy: 
- az első maradjon változatlanul 
- a másodiknál a sorok mezőit fordított sorrendben ( a mezőelválasztó karakter a : ) 
- a harmadikat változatlanul 
- ... 
awk ' 
  BEGIN { i=-1 
          fnev=FILENAME 
          print "=============================================" 
          print "Az allomany neve:", FILENAME 
        } 
        { if (fnev != FILENAME) 
          { 
            i=-1*i 
            print "=============================================" 
            print "Az allomany neve:", FILENAME 
          } 
          if (i>0) 
            print 
          else 
          { 
            for (j=NF; j>0; j--) printf("%s ", $j) 
              printf("\n") 
          } 
          fnev=FILENAME 
        } 
  END   { print "=============================================" } 
' $* 

BOURNE SHELL PROGRAMOZÁS 

A BUROK VÁLTOZÓI 

A Shell a parancssor argumentumait sorszámmal azonosítja és string formában tartja számon. Az i-edik argumentumot tehát $i hivatkozással lehet elérni. 

$# - az argumentumok száma 
$* - a parancssor minden argumentuma 
$- - a burok által adott opciók 
$$ - a burok folyamatazonosítója 
$! - az utolsó, &-el indított folyamat azonosítója 
HOME - a cd parancs default értéke, a felhasználó saját (bejelentkezési) katalógusára állítja be a rendszer 
PATH - a parancsok keresési útvonalat állítja be, azaz hogy a shell hol keresse a végrehajtandó fájlokat. Az egyes elemeket : választja el egymástól. A kurrens katalógus jele a . karakter. 
CDPATH - a cd parancs szamara beállítható keresési útvonal, szinten kettősponttal elválasztva. Ha e változó be van állítva, relatív elérési útvonalak megadásakor a shell megpróbálja illeszteni az általunk begépelt relatív nevet, és ha talált ilyet, oda vált. 
MAIL - az e-mail postaüzeneteket tároló katalógus neve 
MAILCHECK - megadja másodpercekben, hogy milyen gyakran ellenőrizze és írja ki a shell az új posta érkezését. Alapértelmezése 600. Ha értéke 0, minden parancs kiadása után, a prompt kiírása előtt ellenőriz. 
PS1, PS2 - az elsődleges és másodlagos prompt. A default értékek a $ illetve a > karakterek. 
TERM - a felhasználó által használt terminál típusa 
LOGNAME - a felhasználó bejelentkezési azonosítója 
IFS - a belső mezőhatárolók: azon karakterek, amelyek a shell szavait elválasztják (default megadása a szóköz, a tabulátor és az újsor karakterek 
TZ - a helyi időzóna 

A BUROKVÁLTOZÓK ÉRTÉKADÁSA 

$var          - var értéke; semmi ha var nincs deklarálva 
${var}            - u.a.; hasznos, ha alfanumerikus karakterek követik a változó nevet 
${var:-dolog}  - var értéke, ha definiálva van, egyébként dolog. $var változatlan 
${var:=dolog}  - var értéke, ha definiálva van, egyébként dolog. Ha var nincs definiálva, akkor értéke dolog lesz. 
${var:?uzenet} - ha var definiálva van, akkor var értéke, ha nem, akkor kiírja az üzenetet és a burok kilep. Ha az üzenet üres, kiírja, hogy var:parameter 
${var:+dolog}  - dolog, ha var definiálva van, egyébként semmi 

A set parancs kiírja az összes változó értéket. 

Példák 
  
1. 
$ cat > argum 
  echo " A teljes parancssor: $0 $* " 
  echo " A parameterek szama ebben a sorban: $# " 
  echo " Az elso parameter: $1" 
CTRL-D
$ chmod +x argum
$ argum 'elso masod' harmad
  A teljes parancssor: argum elso masod harmad
  A paraméterek száma ebben a sorban: 2
  Az elso parameter: elso masod
$ 
  
2.
$ cat >fordit
  echo $3 $2 $1
CTRL-D
$ chmod +x fordit
$ fordit A B C
  C B A
$ fordit A
  A
$ fordit A B C D
  C B A 

SHELL VALTOZÓK EXPORTJA 
  
Egy létrehozott shell változó mindig ahhoz a shell-hez tartozok, amelyik létrehozta és a shell gyermekeinek, tehát a shell által indított programoknak nem adódik át automatikusan. 
Ha azt akarjuk, hogy egy változót a leszármazott proceszek is megkapjanak, azt exportálni kell. 
Példák. 
  
1. 
$ x = Hello
$ echo $x
  Hello
$ sh        # uj shell inditasa
$ echo $x
$ exit      # most vissza az elozo shell-be
$ echo $x
  Hello
$ 
  
2.
$ x=Hello
$ echo $x
  Hello
$ echo ${y-abc}
  abc
$ echo ${y=abc}
  abc
$ echo $y
  abc
$ echo ${z?szoveg}
  z: szoveg
$ echo ${a+szoveg}
$ echo ${x+szoveg}
  szoveg
$ 
  
3. Írjuk ki a képernyőre:
  Most a ...ban vagyok.
ahol a pontok helyére a HOME változó tartalma kerüljön.
$ echo "Most a ${HOME}ban vagyok."
$ echo "Most a $HOME ban vagyok.
$ echo Most a $HOME ban vagyok 
Az idézőjelben levő és az idézőjelek nélküli stringet a shell egyaránt kielemzi abból a szempontból, hogy kell-e helyettesítenie egy shell változó értéket, azaz a változónév behelyettesítése ellen a dupla idézőjel nem véd. 
A kapcsos zárójel jelezte a shell változó nevének a határait. Ha nem használjuk, egyes esetekben, hasonló nevű shell változók eseten kétértelmű lenne a változónév kiértékelése. 
  
4. Hogyan lehet a képernyőteírni azt, hogy 
  A $HOME erteke ... 
$ echo "A \$HOME erteke: $HOME
$ echo A '$HOME' erteke: $HOME 
A \ jel vagy az ' jel feloldja a $ speciális jelentését. 

UTASÍTÁSOK 

A for utasítás formája a következő: 
  for name in word_list do command_list done 
ahol a word_list egy karakterláncokból álló felsorolás. A for utasítás végrehajtásakor a shell a name változónak sorra a word_list felsorolásban szereplő értékeket adja, s ezzel az értékkel hajtja végre a command_list parancssorozatot. 
Ha az in word_list rész hiányzik a for ciklus megadásakor, akkor a word_list értéket a shell automatikusan $* -nak értelmezi. 
  
Példák: 

1. Írjuk ki az a1, a2 és a3 állományok nevét es tartalmát. 
$ cat >ir1
  for i in a1 a2 a3; do
    echo Az allomany neve: $i
    echo Az allomany tartalma:
    cat $i
  done
CTRL-D 
$ chmod +x ir1 $ ir1 
  
2. Írjuk ki a parancssoban megadott állományok nevét es tartalmát. 
$ cat >ir1
  for i; do
    echo Az allomany neve: $i
    echo Az allomany tartalma:
    cat $i
  done
CTRL-D 
$ chmod +x ir1 $ ir1 

A shift utasítás formája: 
  shift [n] 
A $n+1 $n+2 ... pozicionális változókat átnevezi $1 $2 ... -re. Ha n nincs megadva, akkor értéke 1. 

Példa. 
  
$ cat >shift1
  for i; do echo $i; done
  echo "shift"
  shift
  for i; do echo $i; done
CTRL-D
$ chmod +x shift1
$ shift1 A B C D
  A
  B
  C
  D
  shift
  B
  C
  D
$ cat >shift2
  for i; do echo $i; done
  echo "shift"
  shift 2
  for i; do echo $i; done
CTRL-D
$ chmod +x shift2
$ shift2 A B C D
  A
  B
  C
  D
  shift
  B
  C
$

  
A case elágazási mechanizmus: 
  
  case word in case_part esac 
ahol a case_part a következő lehet: 
  pattern) command_list;; 
  
Az utasítássort 2 pontosvessző zárja. 
  
Példa: 
$ cat >szamok
  case $1 in
         0) echo nulla;;
         1) echo egy;;
         2) echo ketto;;
         3) echo harom;;
         4) echo negy;;
         5) echo ot;;
         6) echo hat;;
         7) echo het;;
         8) echo nyolc;;
         9) echo kilenc;;
     nulla) echo 0;;
       egy) echo 1;;
     ketto) echo 2;;
     harom) echo 3;;
      negy) echo 4;;
        ot) echo 5;;
       hat) echo 6;;
       het) echo 7;;
     nyolc) echo 8;;
    kilenc) echo 9;;
  esac
CTRL-D
$ szamok 3
  harom
$ szamok hat
  6
$ 

A && rövidítés azt jelenti, hogy a parancssor következő parancsa csak akkor fut le, ha az előző parancs visszatérési értéke igaz volt. (0 exit status). 
A || rövidítés azt jelenti, hogy a parancssor következő parancsa csak akkor fut le, ha az előző parancs visszatérési értéke hamis volt. 
  
Példa: 

Cseréljük ki két állomány nevét: 
$ cat >exch
  TMP="temp$$"
  mv $1 $TMP && mv $2 $1 && mv $TMP $2
CTRL-D
$ exch a1 a2

Mivel a PID értékek egyediek, a $$ segítségével egyedi fájlneveket generálhatunk. 

EXIT STATUS 
A parancsok végrehajtásának sikerességérôl informál. Sok Unix parancs, de nem mindegyik, állítja be ezt az értéket, amit a shellben a ? változó $? alakú lekérdezésével tudunk meg. Általában a sikeresen lefutott parancs 0-ra állítja, ellenkezô esetben egy ettôl elterô értékre. Ha egy parancs nem állítja a visszatér&eacutelsi változó értéket, akkor a legutolsó beállítás marad érvényben. 
Példa: 
$ pwd
  /home/h123456
$ echo $?
  0
$ pwdd #feltetelezem, hogy nincs pwdd nevu futtathato allomany
  sh: pwdd: command not found
$ echo $?
  1

ELÁGAZÁSOK 
  
Az if szerkezet: 
  
if command_list1; 
  then command_list2;
  [elif command_list3; then command_list4 elif_part]
  [else command_list;]
fi
A command_list több parancsból is állhat, ezeket a pontosvesszővel, a kerek zárójelekkel vagy a pipe segítségével csoportosíthatuk. Több parancs eseten az utolsó parancs visszatérési kódja számit. 
  
Példa. 
  
$ if date | grep Apr; then echo Tavasz van! fi
  Wed Apr 17 20:57:30 MET 1998
  Tavasz van!
$ 
  
A test parancs szintakszisa: 
  test kifejezes 
A teszt parancs segítségével értékeket, karaktersorokat hasonlíthatunk össze, valamint fájlok tulajdonságait vizsgálhatjuk. Ha az argumentumként megadott kifejezés logikai értéke igaz, akkor a visszatérési érték nulla, egyébként nem-nulla. 

Numerikus értékek összehasonlításakor használható opciók: 
  -eq, -ne : egyenlő, nem egyenlő
  -gt, -lt : nagyobb, kisebb
  -ge, -le : nagyobb vagy egyenlő, kisebb vagy egyenlő

Fájlokkal kapcsolatos opciók: 
  -s : igaz, ha a fájl létezik és nem üres
  -f : igaz, ha a fájl létezik és reguláris állomány
  -d : igaz, ha a fájl létezik és könyvtár
  -x : igaz, ha a fájl létezik és végrehajtható
  -w : igaz, ha a fájl létezik és írható
  -r : igaz, ha a fájl létezik és olvasható

Sztringek összehasonlítása
  = != : a ket sztring egyenlő illetve nem egyenlő
  -z   : igaz, ha a sztring hossza zéró
  -n   : igaz, ha a sztring hossza nem zéró

Példák. 
1. 

$ cat >teszt1 
  if test $# -le 5
  then echo Az argumentumok szama kisebb vagy egyenlo mint 5.
  else echo Az argumentumok szama nagyobb mint 5.
  fi
CTRL-D
$ chmod +x teszt1
$ teszt1 a1 a2 a3
  Az argumentumok szama kisebb vagy egyenlo mint 5.
$ teszt1 a1 a2 a3 a4 a5 a6 a7
  Az argumentumok szama nagyobb mint 5.
$ 

2. Írjunk programot, amelyik megvizsgálja, hogy létezik-e a parancsargumentumként megadott fájl, es ha nem, akkor hozzuk létre. 

$ cat >teszt2 
  if test ! -s $1
  then
    echo A(z) $1 nevu fajl nem letezik, vagy ures!
    ls -l >$1
  else
    echo A(z) $1 nevu fajl letezik!
  fi
CTRL-D 
$ chmod +x teszt2
$ teszt2 a1 
  A(z) a1 nevu fajl letezik! 
$

3. A program írja ki a parancsargumentumait addig, amíg "end"-et nem talál. 

$ cat >teszt3
  if test $# -eq 0
  then
    echo Hianyoznak az argumentumok!
    exit 1
  fi
  while test $1 != "end"
  do
    echo Az argumentum: $1
    shift
    if test $# -eq 0
    then 
      echo A parancsargumentumok nem tartalmazzak az end-et.
      exit 1
    fi
  done
  echo Megtalaltam az end-et! 
CTRL-D 
$ chmod +x teszt3
$ teszt3 a1 a2 end a3
  Az argumentum: a1
  Az argumentum: a2
  Megtalaltam az end-et!
$ teszt3
  Hianyoznek az argumentumok!
$ teszt3 a1 a2 a3
  A parancsargumentumok nem tartalmazzak az end-et.
$ 

4. 

$ cat >teszt4
  if test $# -gt 2 -a $# -lt 5
  then
  echo A parmeterek szama 3 vagy 4.
  fi
CTRL-D 
$ chmod +x teszt3
$ teszt3 a1 a2 a3
  A parmeterek szama 3 vagy 4. $ 

A while és az until ciklusok formája: 
  while command_list1 do commandlist_2 done 
  until command_list1 do command_list2 done 
  
Példák. 
Írjuk ki a parancssoban megadott állományok nevét es tartalmát. 
$ cat >ir2
  while test $# -gt 0; do
    echo Az allomany neve: $1
    echo Az allomany tartalma:
    cat $1
    shift
  done
CTRL-D 
$ 
$ cat >ir2
  until test $# -eq 0; do
    echo Az allomany neve: $1
    echo Az allomany tartalma:
    cat $1
    shift
  done
CTRL-D 
$ 

Az expr parancs szintakszisa: 
  expr argumentumok 
Az expr logikai vagy aritmetikai kifejezésekként kezeli az argumentumokat és kiértekeli azokat. Az eredményt a standard outputra küldi. Az egyes argumentumokat szóközökkel kell elválasztani, a metakaraktereket semlegesíteni kell. 
A használható függvények:
  +  összeadás
  -  kivonás
  *  szorzás
  /  osztás
  %  maradékos osztás
Példák. 
1. Írjunk shell scriptet, amelyik kiírja a 2 parancsargumentum összegét, különbségét és szorzatát. 
$ cat >szamol
  if test $# -ne 2
  then
    echo A programnak pontosan 2 argumentuma kell legyen.
    exit 1
  fi
  SUM=`expr $1 + $2`
  DIFF=`expr $1 - $2`
  PROD=`expr $1 \* $2`
  echo \$1= $1
  echo \$2= $2
  echo $1 + $2 = $SUM
  echo $1 - $2 = $DIFF
  echo $1 \* $2 = $PROD
CTRL-D
$ chmod +x szamol
$ szamol 5 2
  5 + 2 = 7
  5 - 2 = 3
  5 * 2 = 10
$
2. Írjunk shell scriptet, aminek 2 paramétere van. A script számoljon el egyesével az első paramétertől a másodikig és közben írja ki a számokat. 
$ cat >szamol1
  usage="szamol1 arg1 arg2"
  if test $# -ne 2
  then
    echo Tul sok vagy tul keves parameter!
    echo $usage
    exit 1
  fi
  if test $1 -gt $2
  then
    echo Az elso parameter kisebb kell legyen, mint a masodik.
    echo $usage
    exit 1
  fi
  x=$1
  while test $x -le $2
  do
    echo $x
    x=`expr $x + 1`
  done
CTRL-D
$ chmod +x szamol1
$ szamol1 5 2
  Az elso parameter kisebb kell legyen, mint a masodik.
  szamol1 arg1 arg2
$ szamol1 1
  Tul sok vagy tul keves parameter!
  szamol1 arg1 arg2
$ szamol 3 7
  3
  4
  5
  6
  7
$ 

3. Hány Anna nevű user van összesen és ezek közül hányan nincsenek bejelentkezve? 
$ cat >felhasznalok
  x1=`cat /etc/passwd | grep Anna | wc -l`
  x2=`finger | grep Anna | wc -l`
  x3=`expr $x1 - $x2`
  echo x3
CTRL-D
$ chmod +x felhasznalok
$ felhasznalok
  20
$ 

4. Elsőfokú egyenlet megoldása.
$ cat >egyenlet
  usage="usage: egyenlet par1 par2"
  if test $# -lt 2
    then echo $usage
  fi
  if test $1 -eq 0
  then
    if test $2 -eq 0 
    then 
      echo "vegtelen sok megoldas van"
      exit 1
    else
      echo "nincs megoldas"
      exit 1
    fi
  fi
  x=`expr 0 - $2 / $1`
  echo x=$x
CTRL-D
$ chmod +x egyenlet
$ egyenlet 3 3
$ x=-1 $ 

FELADATOK 
  
1. Írjuk ki a képernyőre, hogy 
  date 
Hogyan érhető el, hogy az echo a napi dátumot írja ki? 
  
$ echo date
  date
$ echo "date"
  date
$ echo `date`
  1998. Marcius 26. Csutortok 11:51:27 MET
$ echo '`date`'      # az egyszeres ' elnyomja a ` hatasat
  `date`
$ echo "`date`"
  1998. Marcius 26. Csutortok 11:51:27 MET

2. Írjuk ki, hogy egy fel perc múlva milyen folyamatok futnak a gépen. 
$ (sleep 30; ps)& 

3. Írjuk ki és számoljuk meg, hogy egy script indítása után hány shell fut. 
$ cat >shellek
  ps | grep sh >temp
  echo "A futo shellek szama: `cat temp | wc -l`"
  echo "A futo shellek az alabbiak:\n `cat temp`"
CTRL-D
$ chmod +x shellek
$ shellek 

4. Nézzük meg, hogy egy bizonyos felhasználó dolgozik-e és fut-e a épp valamilyen folyamata. 
$ cat >dolgozik
  if who | grep $1 >temp; then
    echo "$1 dolgozik"
    if ps -ef | grep $1; then
      echo "a folyamatok"
    fi
  else echo "$1 nem dolgozik."
  fi
CTRL-D
$ dolgozik h123456
  h123456 nem dolgozik.
$

5. Írjunk "ébresztőórát" ami minden egész órakor üzenetet küld a képernyőre. 
  
$ cat >alarm1
  until date | grep ':00:' >temp/FONT>
  do
    sleep 30
  done
  echo Haho!
CTRL-D
$ 
  
6. Hozzunk létre egy sorsz nevű programot, ami az f1 fájl sorainak számozásával állítja elő az f2 állományt. 

$ cat >sorsz
  k=1
  while sor=`line`; do
    echo $k $sor
    k=`expr ${k} + 1`
  done
CTRL-D
$ 

  
  
7. Van-e egy bizonyos évben hétfővel kezdődő hónap? Ha találunk ilyet, írjuk ki betűkkel a hónap nevét. 
$ cat hetfo
  k=ures
  p=elso
  for i in 1 2 3 4 5 6 7 8 9 10 11 12; do
    if cal $i $1 | grep ' 6$' >temp
    then
      k=nemures
      ho=abc
      case $i in
        1) ho=januar;;
        2) ho=februar;;
        3) ho=marcius;;
        4) ho=aprilis;;
        5) ho=majus;;
        6) ho=junius;;
        7) ho=julius;;
        8) ho=augusztus;;
        9) ho=szeptember;;
        10) ho=oktober;;
        11) ho=november;;
        12) ho=december;;
      esac
    fi
    if test $k = 'nemures'; then
      if test $p = 'elso'; then
        echo Az $1 evben hetfovel kezdodik
        p=masod
      fi
      echo $ho
      k=ures
    fi
  done
  if test $p = 'elso'; then
    echo Az $1 evben nincs
  fi
CTR-D
$ chmod +x hetfo
$ hetfo 1993
  Az 1993 evben hetfovel kezdodik
    februar
    marcius
    november
$ hetfo 1998
    Az 1998 evben hetfovel kezdodik
    junius
$ 
  
awk feladatok 
1. Adjuk meg egy allomany azon sorat, amelyik a legtobbszor szerepel egymas utan az allomanyon belul. Ezen kivul irjuk ki az allomany nevet, 
valamint azt, hogy hanyszor ismetlodot az illeto sor. 
2. Adott n allomany, n termeszetes szam. Irjuk ki az allomany azon sorainak a sorszamat, amelyeknek a hossza nagyobb, mint 10 karakter es irjuk ki 
azokat a sorokat, amelyeknek a hossza kisebb, mint 10 karakter. Egy allomany elemzese utan irjuk ki a nevet es a valtozatlanul kiirt sorok szamat. 
3. Irjuk ki minden allomanybol a mezok elso 3 akrakteret. Ha a mezo hossza kisebb mint 3, akkor egeszitsuk ki szokozokkel. Egy allomany elemzese 
utan irjuk ki a nevet es a mezok szamat. 
4. Adott n allomany, n termeszetes szam. Minden sorra, amelynek hossza nagyobb, mint 30 karakter, irjuk ki a sor sorszamat (az allomanyon belul), az 
elso mezot es az utolsot. Egy allomany elemzese utan irjuk ki a nevet es a mezok szamat. 
5. Adjuk ossze n allomany minden soranak elso mezojet es szamoljuk ki az utolso mezok atlagat. 
6. Adott n allomany, n termeszetes szam. Irjuk ki az allomanyok azon sorait, amelyekben letezik olyan szo, hogy egymas utan tobbszor szerepeljen. 
Irjuk ki a sorok sorszamat is. 
7. Adott n allomany, n termeszetes szam. Irjuk ki minden allomany nevet, a benne levo mezok szamat, valamint azt, hogy atlagosan hany szo van egy 
allomanyban. 
8. Adott n allomany, n termeszetes szam. Irjuk ki annak az allomanynak a nevet, amelyik a legtobb mezot tartalmazza. Adjuk meg a mezok szamat is. 
9. Adott n allomany, n termeszetes szam. Irjuk ki az allomanyok azon sorait, amelyek tartalmaznak egy bizonyos karaktersort, legalabb k-szor. A 
karaktersort es a k erteket rgumentumkent adjuk meg. Egy allomany elemzese utan irjuk ki a nevet. 
10. Adott n allomany, n termeszetes szam. Az allomany szerkezete: 
        Nev ZH1 ZH2 ZH3 
Irjuk ki a neveket es a hozzajuk tartozo 3 ZH atlagat. Ezen kivul szamoljuk ki a ZH1, ZH2 es ZH3 oszlopok atlagat is. (Minden allomanyra 
kulon-kulon.) 
  
shell scriptek 
1. Írjunk shell scriptet, amelyik kiszámolja, hogy az évnek hányadik napja van. 
2. Írjunk shell scriptet, amelyik kiszámolja, hogy az évből hány nap van még hátra. 
3. A bc parancs segítségével bármilyen pontosságú aritmetikai műveleteket végezhetünk. Írjunk példaprogramot ennek bemutatására. 
4. Írjunk shell scriptet, amelyik megmondja, hogy milyen névnap van ma es mikor van még ilyen névnap. ( A névnapokat egy fileban lehet tárolni.) 
5. Írjunk shell scriptet, amelyik megmondja, hogy milyen névnap van ma es küldjon köszöntő levelet minden névnapját ünneplő ismerősödnek. 
6. Parancsargumentumbol megadva egy felhasználó teljes nevét (nem az azonosítóját) mondjuk meg, hogy be van-e jelentkezve és ha igen, milyen 
folyamatokat futtat. 
7. Írjunk egy shell scriptet amelyik egy parancsargumentumként megadott, C forráskódot tartalmazó fileból megadja az összes ott deklarált függvény 
fejlécét. 
8. Írjunk egy shell scriptet amelyik egy parancsargumentumként megadott, Pascal forráskódot tartalmazó fileból megadja az összes ott deklarált 
függvény fejlécét. 
9. Írjunk egy shell scriptet amelyik egy parancsargumentumként megadott, Pascal forráskódot tartalmazó fileból megadja az összes ott deklarált 
eljárás fejlécét. 
10. Írjunk shell scriptet, amelyik megmondja, hogy hány levelem érkezett és kitől.