bash

Ki- és bemenetek átirányítása, különleges shell parancsok

A UNIX operációs rendszerben a felhasználó belépésekor egy ún. shell (burok, héj) program indul el:

fogadja a parancsokat
feldolgozza a parancsokat (interpreter)
továbbadja az egyes speciális programoknak
összefűzi az adatfeldolgozást egy egész parancsláncon keresztül (a programok ki- és bemeneteit össze tudja kapcsolni)
- standard input/bemenet (0)
- standard output/kimenet (1)
- standard error/hibakimenet (2)

Parancs kimenetének átirányítása

Egy program végeredményét egy állományba is beleírhatjuk a képernyő helyett. Ehhez a parancs után egy > jelet, majd a kívánt állománynevet kell írnunk.

Például:

$ ls -l > filenév
$ cat filenév
total 152
-rw-r--r-- 1 zsolt astro 8351 Mar 3 22:45 alap2.txt
-rw-r--r-- 1 zsolt astro 8570 Mar 2 23:16 alap3.txt
-rw-r--r-- 1 zsolt astro 18171 Mar 2 23:14 archive.txt
-rw-r--r-- 1 zsolt astro 4745 Mar 3 22:51 job1.txt
-rw-r--r-- 1 zsolt astro 769 Mar 2 23:14 kommun.txt
-rw-r--r-- 1 zsolt astro 36404 Mar 2 23:49 ksh.txt
-rw-r--r-- 1 zsolt astro 19577 Mar 2 23:19 network.txt
-rw-r--r-- 1 zsolt astro 23165 Mar 2 23:14 szerk.txt
-rw-r--r-- 1 zsolt astro 8766 Mar 2 23:20 tcpip1.txt
-rw-r--r-- 1 zsolt astro 2680 Mar 2 23:20 filelista

$

Az átírányítás felülírja a már létező állományt. Ha ehelyett az állomány végéhez akarjuk az eredményt fűzni, akkor a >> jelet kell használjuk.

ls > filenév
ls -l >> filenév
cat filenév
alap2.txt alap3.txt archive.txt job1.txt kommun.txt ksh.txt
network.txt szerk.txt tcpip1.txt write.txt
total 152
-rw-r--r-- 1 zsolt astro 8351 Mar 3 22:45 alap2.txt
-rw-r--r-- 1 zsolt astro 8570 Mar 2 23:16 alap3.txt
-rw-r--r-- 1 zsolt astro 18171 Mar 2 23:14 archive.txt
-rw-r--r-- 1 zsolt astro 4745 Mar 3 22:51 job1.txt
-rw-r--r-- 1 zsolt astro 769 Mar 2 23:14 kommun.txt
-rw-r--r-- 1 zsolt astro 36404 Mar 2 23:49 ksh.txt
-rw-r--r-- 1 zsolt astro 19577 Mar 2 23:19 network.txt
-rw-r--r-- 1 zsolt astro 23165 Mar 2 23:14 szerk.txt
-rw-r--r-- 1 zsolt astro 8766 Mar 2 23:20 tcpip1.txt
-rw-r--r-- 1 zsolt astro 2680 Mar 2 23:20 filelista

Bemenet átirányítása

Nem csak a képernyőre való kiírást (az ún. standard outputot) hanem a billentyűzeten történő adatbevitelt (standard input) is átirányíthatjuk.

Például a grep parancs állomány megadása nélkül a bemenetről olvassa a sorokat, és keresi bennük a megadott szót:

grep 'ben'
Itt nincs a keresett karakter
Ebben mar van
Ctrl-D
Ebben mar van

Irányítsuk át a bemenetet a gyakorlas állományból! Ehhez a < jelet kell használnunk:

grep 'ben' < gyakorlas
Ebben a sorban mar vannak szamok is , peldaul az 1 es a 42
Ebben a sorban nehany furcsa karakter van
Most mindent egyutt szerepeltetunk ebben a sorban 'vege'

Hiba kimenet

Alapesetben a hibakimenet a képernyőre kerül, még olyankor is, amikor a standard kimenet át van irányítva. Lehetőség van a hibakimenet külön, és a standard kimenettel történő együttes átirányítására is:

A 2>&1 a stderr-t (2) irányítjuk át az 1. fájldeszkriptorhoz tartozó kimenetetre.
Sorrend:

a.out 2>&1 >tmp stdout a tmp-be, stderr a képernyőre irányul
a.out >tmp 2>&1 stdout a tmp-be, stderr a tmp-be irányul

Cső/pipe

A cső/pipe lehetővé teszi, hogy egy program végeredményét egy másik program használja, külön állomány létrehozása nélkül.

Egy parancssorban több átirányítást is használhatunk, pl. az első utasítás a bemenetét egy megadott állományból veszi, majd a második parancs az első kimenetét (eredményét) dolgozza fel, végül a harmadik a második kimenetét továbbalakítva a végeredményt egy kimeneti állományba írja.

Mindez nagy közbülső állományok létrehozása nélkül történik, ezért sokkal gyorsabb a parancsok egyenkénti futtatásánál.

Példák:

Kilistázzuk a /bin könyvtár tartalmát az ls parancs segítségével és az eredményt a more segítségével jelenítjük meg:
$ ls -l /bin | more
A who parancs kiírja az aktuális felhasználókat (soronként egyet), a wc -l parancs pedig megszámolja a sorok számát. Így az éppen aktív felhasználók számát a
$ who | wc -l
adja meg.

Parancs eredményének továbbhasználata

Bizonyos esetekben szükségünk lehet egy parancs eredményére, de nem bemenetként, hanem egy utasítás argumentumaként. Ilyenkor a fordított aposztróf karakterek közé kell zárni a forrásként szereplő utasítást: a fordított aposztrófok közé írt parancs végeredménye közvetlenül behelyettesítődik a parancssorba.

Például

more ` grep -l 'egy' * `

parancs minden, az egy szót tartalmazó állományt megjelenít a képernyőn.

Parancsállományok létrehozása

Néha egymás után többször ugyanazt a parancssorozatot kell lefuttatnunk. Ilyenkor célszerű lehet ezt egy állományban, új parancsként összefoglalni.

Például hozzuk létre egy szövegszerkesztővel a ddir állományt, a következő tartalommal:

echo "Most kovetkezik az allomanylista"
ls -l
echo "Vege van az allomanylistanak"

Ezután változtassuk meg az állomány védelmi kódját futtathatóra:

chmod +x ddirEnter

majd a ddir parancs egymás után lefuttatja a három parancsot.

Programok futtatása

A UNIX operációs rendszerben

egyszerre több parancsunk is futhat párhuzamosan
a programok az előtérben és háttérben futhatnak
a háttérben futó eljárások is írhatnak a képernyőnkre, de nem kaphatnak bemenő adatokat a billentyűzetről.
Egy végrehajtható programot a nevével futtatunk (nem szükséges az .exe, vagy hasonló végződés!).
a UNIX a parancsokat a PATH környezeti változóban megadott könyvtárakban sorra keresi a PATH-ban megadott sorrend szerint, és az első találatot kezdi el futtatni
Egy már futó programot a Ctrl-Z gombok egyidejű lenyomásával állíthatunk meg.
Az így leállított program még benne van a gépben, csak nem fut, bármikor folytatható a futtatása.
Ha egy programból ki akarunk lépni úgy, hogy az befejezze a futást,programmegszakítása a Ctrl-C lenyomásával tehetjük ezt meg.

A háttérbe tett (futó vagy megállított) programokat a jobs paranccsal nézhetjük meg.

$ jobs
[1]- Running mozilla &
[2]+ Stopped mutt

A programokat az fg (foreground) paranccsal előtérbe, a bg (background) paranccsal háttérbe tehetjük.
A parancsoknak meg kell adni, hogy melyik programot akarjuk elő- vagy háttérbe tenni. Ha nem adunk meg azonosítót, akkor a parancs az aktuális programra hat. Pl. a 2-es számú program háttérben való továbbfuttatása a

$ bg %2

paranccsal történik.

Egy parancsot futtathatunk azonnal a háttérben. Ehhez a parancs legvégére tegyünk egy & jelet.
A háttérben futó parancsok kisebb prioritással bírnak, s így terhelt rendszeren lassabban futnak le.
Ha sokan futtatnak a rendszeren, célszerű más módon elküldeni a futtatásokat (queue rendszer).
A háttérben indított parancsok befejezik futásukat, ha kijelentkezünk a gépről.
Ha ezt el akarjuk kerülni, akkor a háttérbe küldendő parancs elé be kell írni a nohup parancsot:

$ nohup Program > KimenetiFile

Például a következő parancs a háttérben futva a lista állományba beleírja az összes, az adott könyvtárban és az alkönyvtárakban található hello.c állomány nevét:

$ nohup find . -name hello.c -print > lista &

Minden futó eljárásnak a rendszerben van egy azonosító száma, az ún. PID (Process IDentification number).
A PID megadja az elindított program sorszámát a gép elindítása óta, s így egyedi az adott gépen futó programokra (pl. a futó shellünknek is van ilyen száma). A bejelentkezési shellhez tartozó programokat a ps paranccsal kérdezhetjük le. Ha más terminálon is dolgozunk, akkor a

ps -u FelhasználóiNév

paranccsal kérdezhetjük meg az adott FelhasználóiNévhez tartozó összes futó eljárást Ezt azt utasítást BSD alapú gépeken ps -u formában kell helyesen kiadni..

Hasznos lehet még a

$ ps axuww | head
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root   1 0.0 0.0 620 256 ?     S 21:47 0:03 init
root   2 0.0 0.0   0   0 ?    SW 21:47 0:00 [keventd]
root   3 0.0 0.0   0   0 ?   SWN 21:47 0:00 [ksoftirqd_CPU0]
root   4 0.0 0.0   0   0 ?    SW 21:47 0:00 [kswapd]
root   5 0.0 0.0   0   0 ?    SW 21:47 0:00 [bdflush]
root   6 0.0 0.0   0   0 ?    SW 21:47 0:00 [kupdated]
root   7 0.0 0.0   0   0 ?    SW 21:47 0:00 [kinoded]

vagy a

$ ps -elf | head
F S UID PID PPID C PRI NI ADDR SZ WCHAN STIME TTY TIME   CMD
0 S root 1    0 0 75 0 - 155 schedu 21:47 ? 00:00:03 init
0 S root 2    1 0 75 0 -    0 contex 21:47 ? 00:00:00 [keventd]
0 S root 3    1 0 94 19 -    0 ksofti 21:47 ? 00:00:00 [ksoftirqd_CPU0]
0 S root 4    1 0 85 0 -    0 kswapd 21:47 ? 00:00:00 [kswapd]
0 S root 5    1 0 85 0 -    0 bdflus 21:47 ? 00:00:00 [bdflush]
0 S root 6    1 0 75 0 -    0 schedu 21:47 ? 00:00:00 [kupdated]
0 S root 7    1 0 85 0 -    0 kinode 21:47 ? 00:00:00 [kinoded]
0 S root 11    1 0 75 0 -    0      ? 21:47 ? 00:00:00 [kjournald]

A felesleges programjainkat le is állíthatjuk a kill parancs segítségével. A

$ kill -9 PID-szám

parancs leállítja a PID-szám azonosítójú eljárást. A

$ kill -9 %2

leállítja a 2. számú háttéreljárást. A -9 kapcsoló az ún. trap jel értéke.

/usr/include/bits/signum.h :
/* Signals. */
#define SIGHUP 1 /* Hangup (POSIX). */
#define SIGINT 2 /* Interrupt (ANSI). */
#define SIGQUIT 3 /* Quit (POSIX). */
#define SIGILL 4 /* Illegal instruction (ANSI). */
#define SIGTRAP 5 /* Trace trap (POSIX). */
#define SIGABRT 6 /* Abort (ANSI). */
#define SIGIOT 6 /* IOT trap (4.2 BSD). */
#define SIGBUS 7 /* BUS error (4.2 BSD). */
#define SIGFPE 8 /* Floating-point exception (ANSI). */
#define SIGKILL 9 /* Kill, unblockable (POSIX). */
#define SIGUSR1 10 /* User-defined signal 1 (POSIX). */
#define SIGSEGV 11 /* Segmentation violation (ANSI). */
#define SIGUSR2 12 /* User-defined signal 2 (POSIX). */
#define SIGPIPE 13 /* Broken pipe (POSIX). */
#define SIGALRM 14 /* Alarm clock (POSIX). */
#define SIGTERM 15 /* Termination (ANSI). */
#define SIGSTKFLT 16 /* Stack fault. */
#define SIGCLD SIGCHLD /* Same as SIGCHLD (System V). */
#define SIGCHLD 17 /* Child status has changed (POSIX). */

....

Csak a saját programjainkat tudjuk leállítani.
A UNIX rendszer minden futó eljáráshoz egy ún. prioritási értéket rendel: minél kisebb ez a szám, annál nagyobb százalékát kapja meg a CPU időnek az adott program.
Ha nagy és hosszú háttérben futó programot akarunk elindítani, ajánlatos ezt nagyobb prioritási értékkel (``lassabb futással'') elindítani.
A csökkentett prioritás beállítása:

$ nice [-Szám] Parancs

a Szám 1 és 19 közti érték, és a növekvő értékek csökkenő prioritásra utalnak. Az alapérték a 10.

A nice magától nem futtat a háttérben, ezért általában a háttérben a következő típusú paranccsal futtathatunk:

$ nohup nice Program > KimenetiFile

A prioritást egy már futó programnál is átállíthatjuk a renice parancs segítségével:

$ renice Új-prioritás PID-szám

ahol a PID-szám az átállítandó program azonosítóját jelenti.

A bash shell

A UNIX rendszereken többféle shell (burok) program futtatható:

legrégibb a Bourne (sh vagy bsh)
C nyelv szintaxisát követő C-shell (csh).

Korn shell (ksh)

bash - GNU Bourne-Again SHell

A bash shell maga egy interaktív parancsértelmező és programozási nyelv, amely a következő funkciókat tartalmazza:

shell parancsok

függvények, feltételek és aritmetikai kifejezések kiértékelése

különleges parancsok

job vezérlés

parancs helyettesítés

állománynév helyettesítés

bemenet és kimenet átirányítása

helyettesítő nevek alkalmazása

~ (tilde) helyettesítés

paraméter helyettesítés

parancssor szerkesztése

Ha a bash shellt bejelentkezéskor hívja meg a rendszer, az végrehajtja a /etc/profile shell állomány parancsait, majd sorban a ~/.bash_profile, ~/.bash_login, és ~/.profile állományok parancsait.

Kilépéskor végrehajtja a ~/.bash_logout parancsait.

Ha a bash shell nem-bejelentkezéskori interaktív shellként fut, akkor megpróbálja a ~/.bashrc állomány parancsait futtatni.

Amennyiben a bash parancs után megadunk egy állománynevet, akkor az adott állományban felsorolt shell parancsok végrehajtódnak. A megadott állománynak olvashatónak kell lenni (ld. chmod parancs).

A környezeti változók

A környezetváltozók tárolják az egy-egy program számára átadható információkat. A környezetváltozónak van egy neve és ehhez rendelhetünk értéket. Értéket egyszerűen a

$ Név=Érték

utasítással adhatunk a változónak (C-shellben ez set Név Érték alakú).. Ez az értékadás csak az adott shellre érvényes, ha azt akarjuk, hogy az abból nyíló újabb shellek is átvegyék a környezetváltozót, azt exportálni kell:

$ export Név

(A C-shellben a set helyett a setenv paranccsal kell ilyenkor értéket adni)

A leggyakrabban használt környezetváltozók közé tartozik a

TERM, mely a terminálunkat azonosítja a rendszer számára, a

LOGNAME, (USER) mely bejelentkezési nevünket tartalmazza, a

PWD, mely az aktuális könyvtár nevét adja meg, a

PATH pedig a parancsok keresési útvonalát tartalmazza.

Interaktív használatkor a shell a parancsokra a PS1 környezetváltozóban definiált prompttal vár. A bash shell a PS1 értékét a prompt kiírása előtt mindig kiértékeli. Így a

$ export PS1='$PWD >'

parancs hatására a prompt mindig az aktuális könyvtárnév lesz (a PS1 változó mindig az aktuális PWD változó értékét fogja tartalmazni).

Amennyiben a parancsot nem fejeztük be az ``újsor'' karakter (Enter) kiadása előtt (pl. a ' vagy " nyitó karaktereknek nem adunk meg párt), akkor a bash shell a PS2 környezetváltozó értékét rakja ki másodlagos promptként.

A parancsok kiértékelése a shellben

Minden alkalommal, amikor átadunk egy parancsot a rendszernek, a shell kiértékeli, és feldolgozza azt.
Amennyiben a rendszer egy speciális beépített parancsát adjuk ki, az az adott shellben hajtódik végre (például a test parancsra a shell beépített utasítása hajtódik végre, még akkor is, ha létezik általunk létrehozott, test nevű futtatható állomány), örökölve annak összes környezetváltozóját, és amennyiben futása közben állított környezetváltozókat, azok a megváltozott értékükkel lesznek elérhetők a parancs lefutása után.
A következő lépésben a shell leellenőrzi, hogy a kiadott parancs nem egy általunk megadott függvény-e. Amennyiben igen, a pozícionális paraméterek (azaz az adott parancs parancssorban lévő argumentumai) elmentődnek, majd behelyettesítődnek a függvénybe.
- Amikor a függvény lefut, a shell visszatölti az eredeti paramétereket.
- Egy függvény mindig az utoljára végrehajtott parancs visszatérési értékével fejezi be a futását, hacsak a return utasítással nem adunk neki más értéket. A függvény az aktuális shellben hajtódik végre.
Amennyiben a parancs fordítás és linkelés eredménye (pl. az a.out állomány), akkor az adott shellben futtatja le.
Ha a utasítás se nem linkelt ill. beépített parancs, se nem függvény, akkor azt a shell parancsokat tartalmazó állománynak tekinti, és alshellt indít el azok beolvasására és végrehajtására.
- Ilyenkor a nem exportált alias- és függvénydefiniciók nem adódnak át. A zárójelek közti parancsok is alshellben futnak le, de megkapják a nem exportált változókat is.
A parancsot a rendszer a PATH környezetváltozó értékeként megadott könyvtárakban keresi.
- A PATH-ban több könyvtárnevet is megadhatunk, egymástól kettősponttal elválasztva.
- A parancs keresése a megadott felsorolási sorrendben történik.
  
  PATH=/opt/lheasoft/i686-pc-linux-gnu/scripts:/opt/lheasoft/i686-pc-linux-gnu/bin:/home/zsolt/bin:/bin:/usr/bin:/usr/X11R6/bin:/usr/local/bin:/usr/games:/opt/gnome/bin:/opt/kde3/bin:/usr/lib/java/jre/bin:
  ~/bin/linux:~/bin/linux:~/bin/linux:.

Amennyiben a parancs /jelet tartalmaz, akkor a shell nem használja a PATH értékét, hanem megpróbálja útvonalként értelmezni a parancsot.
A parancsot csak akkor indítja el a shell, ha annak védelmi kódja (amit a chmod paranccsal állíthatunk be) lehetővé teszi a futtatást.

Védőkarakterek

Minden ún. metakarakter, ezek a

\ fordított törtvonal

' aposztróf

` fordított aposztróf

" macskaköröm

() gömbölyű

[] {}szögletes és kapcsos zárójelek,

<> kisebb és nagyobb jel

| függőleges vonal

& és-jel

; pontosvessző

* csillag

? kérdőjel

$ dollár
speciális jelentést hordoz a shell számára.

Amennyiben azt akarjuk, hogy a shell ne értelmezzen egy karaktert, akkor azt le kell védeni.

Egy karaktert az elé helyezett fordított törtvonal (\) védi meg a shell kiértékelésétől.
A sor végén álló \ azt jelzi, hogy a parancs a következő sorban folytatódik.
Több karaktert aposztrófok (') közé kell tenni (ezzel az szövegben előforduló aposztrófot nem tudjuk levédeni).
A macskakörmök közötti szövegrészben végrehajtódik a paraméter- és parancshelyettesítés, de a fordított törtvonal levédi
a fordított törtvonalat, a fordított aposztrófot (`), a macskakörmöt (") és a dollár ($) jelet.
A macskakörmök és aposztrófok közötti részt a shell egy szónak kezeli (egy pozíciós paramétert foglal).
A * és @ pozíciós paraméterek (az összes átadott argumentum) egyforma hatású amikor nem tesszük macskakörmök közé, de macskakörmök között a * egy szóként kezeli az összes átadott paramétert, míg a @ minden paramétert külön szóba ír.
A fordított aposztrófok között a fordított törtjel levédi a fordított aposztrófot és a dollár jelet. Amennyiben a fordított aposztróf macskakörmök között fordul elő, akkor a fordított törtvonal levédi a fordított aposztrófok közötti macskakörmöt is.
A fenntartott szavak valamint a helyettesítő nevek (alias) felismerését megakadályozhatjuk, amennyiben bármelyik karakterüket levédjük (ezek felismerése még a védőkarakterek kiértékelése előtt történik). A beépített parancsok, valamint a függvények felismerését ilyen módon nem akadályozhatjuk meg.

Parancssor szerkesztés

A bash shell az utolsó végrehajtott parancsokat a $HOME/.bash_history állományban tárolja el.
Az állomány neve a HISTFILE környezetváltozóval megváltoztatható, az eltárolt parancsok számát meg a HISTSIZE környezetváltozó értéke szabja meg.
Alapbeállításban a begépelt parancsok a bejelentkezések között is eltárolódnak, és amennyiben egyszerre több bejelentkezésünk is fut ugyanazon a gépen, akkor mindegyik ugyanabba az állományba írja be a begépelt parancsokat, ezért más bejelentkezésben beírt parancsainkat is visszahívhatjuk.
A !-jel kezdődő parancsot a shell a felkiáltó jel utáni kifejezéssel kezdődő utolsó elmentett paranccsal helyettesíti. Példa:

$ ls -ltr

total 13796
-rw-r--r-- 1 pg users 11168929 2003-12-10 20:33 winttf.tgj
drwxr-xr-x 2 pg users     4096 2004-03-02 16:34 fonts
drwxr-xr-x 2 pg users     4096 2006-02-22 16:16 Norveg
drwxr-xr-x 2 pg users     4096 2006-04-10 15:06 RET
-rw-r--r-- 1 pg users 2178472 2006-04-11 11:51 pgf-1.01.tar.gz
-rw-r--r-- 1 pg users    68129 2006-04-11 11:53 xcolor-2.00.tar.gz
-rw-r--r-- 1 pg users     5426 2006-04-16 13:59 knowledgecollage.jpg

$ !l

ls -ltr

total 13796
-rw-r--r-- 1 pg users 11168929 2003-12-10 20:33 winttf.tgj
drwxr-xr-x 2 pg users     4096 2004-03-02 16:34 fonts
drwxr-xr-x 2 pg users     4096 2006-02-22 16:16 Norveg
drwxr-xr-x 2 pg users     4096 2006-04-10 15:06 RET
-rw-r--r-- 1 pg users 2178472 2006-04-11 11:51 pgf-1.01.tar.gz
-rw-r--r-- 1 pg users    68129 2006-04-11 11:53 xcolor-2.00.tar.gz
-rw-r--r-- 1 pg users     5426 2006-04-16 13:59 knowledgecollage.jpg

Visszatérési értékek

Minden lefuttatott parancs egy u.n. visszatérési értéket ad vissza az őt elindító shellnek (programnak).
Ha külön, a return utasítással nem adunk neki más értéket, akkor egy shell scriptben ezt normális lefutás esetén az
utolsó lefuttatott parancs visszatérési értéke adja meg.
A futás közbeni hibákat a shell kiírja a hibát tartalmazó sor számával (egynél több sor esetén), a hívott függvény nevével és a hibaüzenettel együtt.

A bash shell kapcsolói

A bash shell lefuttatható programként is (akárcsak a többi shell). A bash parancsnak megadhatók kapcsolók is (melyeket a már futó shellben is állíthatunk a set paranccsal).

A bash-shell beépített parancsai

A bash shell a következő fenntartott szavakat ismeri fel, amennyiben azok a parancs első szavai, védőkarakaterek nélkül:

if for case then
while esac else until function
elif do select fi
done time [[ ]]

for Azonosító [in Érték ...]; do ParancsLista ;done

Minden alkalommal, amikor a for parancs lefut, az Azonosító értéke az Érték következő szavát veszi fel. Ha nem adjuk meg az in Érték kifejezést, akkor a ParancsListában felsorolt parancsokat a pozíciós paraméterekre hajtja végre.

Példa:

$ for i in 1 2 3 4 5 6; do echo $i; done

1

2

3

4

5

6

select Azonosító [in Érték ...] ;do ParancsLista ;done

A select parancs kinyomtatja a standard hibakimeneten az Értékben felsorolt szavakat, sorszámmal ellátva. Ha nem adjuk meg az Értéket, a pozíciós paramétereket használja a shell. A PS3 környezetváltozóban definiált promptot kiírva olvassa be a választ.

Amennyiben a beolvasott sor tartalmaz egy számot, akkor az Azonosító értéke a kiválasztott szó lesz, üres sor esetén a választási lista jelenik meg újra, egyébként pedig az Azonosító nem kap értéket. A beolvasott sort a REPLY környezetváltozó tartalmazza. Minden kiválasztásra végrehajtódnak a ParancsListában felsorolt parancs(ok).

Példa:

$ select ans in "Telepítés" "Eltávolítás" "Kilépés"; do if [[ $ans = exit ]]; then exit; fi; done

1) Telepítés

2) Eltávolítás

3) Kilépés

#?

case Szó in [[ ( ] Minta[ Minta] ... ) ParancsLista ;;] esac

A case parancs végrehajtja a Szóval egyező első Mintához tartozó ParancsListát. A Minta az állománynév helyettesítésben ismertetetett helyettesítő karaktereket tartalmazhat.

Példa:

while getopts ":ab:c" opt;

do

case $opt in

    a*) process_option_a;;

    b) process_option_b $OPTARG;;

    c) process_option_c;;

esac

done

if Lista ;then ParancsLista [elif ParancsLista ;then ParancsLista] ... [;else ParancsLista] ;fi

Az if parancs végrehajtja az első ParancsListában felsorolt parancsokat, és ha az utolsó nulla visszatérési értéket ad, akkor az utána következő ParancsListát hajtja végre.
Ellenkező esetben az elif utáni részt értékeli az előzőhöz hasonlóan. Amennyiben egy feltételnél sem nulla a visszatérési érték az else utáni ParancsListát hajta végre.

Példa: ld. a select parancsnál

while Lista ;do ParancsLista ;done

until Lista ;do ParancsLista ;done

A while parancs folyamatosan végrehajtja az utána felsorolt parancsokat, és amennyiben az utolsó parancs visszatérési értéke nulla, végrehajtja a do utáni parancssorozatot, különben kilép a hurokból
Az until parancs hasonlóan működik, csak a feltételnek nulla értékére lép ki a hurokból.

Példa: ld. a case parancsnál

( ParancsLista )

A ParancsLista parancs(sorozatot) külön környezetben hajtja végre, így a végrehajtás során létrejött vátozások (környezetváltozó módosítása, könyvtárváltás) nem befolyásolják a munkakörnyezetünket. Amennyiben egymásba kell ágyazni több ilyen hívást, tegyünk szóközt a zárójelek közé, mivel az aritmetikai kiértékelés használja a kettős zárójelet (a (( jelet).

{ ParancsLista ;}

Egyszerűen végrehajtja a parancsokat. Mivel a kapcsos zárójel fenntartott szó, ezért a shell csak akkor ismeri fel, ha a sor elején vagy a parancsokat elválasztó pontosvessző után áll.

[[ Kifejezés ]]

Kiértékeli a Kifejezést, és nulla értékkel tér vissza, ha az igaz.

function Azonosító () {ParancsLista} ;

az Azonosítóhoz rendel egy függvényt (név). A függvény a {} közötti ParancsListában felsorolt parancsokat hajtja végre.

time Parancssorozat

Végrehajtja a Parancssorozatot és kiírja a felhasznált rendszer- és felhasználói időt a standard hibakimeneten.

A függvények

A parancshoz hasonlóan a függvényeknek is átadhatunk pozicionális paramétereket.
A függvények a hívó paranccsal egy eljárásban (process) futnak le, és megosztják annak erőforrásait (könyvtár, állományok, nyomkövetés, nyomkövetés változók ...).
A függvényből a return speciális paranccsal térhetünk vissza. A függvény végrehajtása során fellépő hiba is felfüggeszti a függvény futását.

Feltételes kifejezések

A feltételeket a test, az [ és ] illetve a [[ és ]] parancspárral adhatjuk ki, állományok jellemzőinek vizsgálatára, számok, stringek összehasonlítására.
A shell nem bontja fel szavakra, és nem hajt végre állománynév helyettesítést a [[ és ]] jelek között. Minden kifejezést a következő kifejezésekből állíthatunk össze:
- [-a File] Igaz, ha a File létezik.
Összetett kifejezéseket ezekből a következőképp gyárthatunk (csökkenő prioritással):
- [(Kifejezés)] Igaz, ha a Kifejezés igaz. A kifejezések csoportosítására használjuk.
- [Kifejezés1 || Kifejezés2] Igaz, ha vagy a Kifejezés1 vagy a Kifejezés2 igaz.Az || helyett a -o feltétel is használható.

Speciális parancsok

A legfontosabb beépített parancsok:

. file
Beolvassa a file-t, majd végrehajtja az aktuális shellben és környezetben. A file-t a PATH környezetváltozó alapján keresi meg. A visszatérési érték az utolsó végrehajtott parancs visszatérési értéke. A . parancs beolvassa a teljes file-t mielőtt végrehajtaná. Ezért a file-on belüli alias, stb. parancsoknak már nem lesz hatása a végrehajtás során. Ha interaktív bejelentkezésből futtatunk így, akkor az állományban található exit utasítás hatására mindjárt a shellből is kilépünk. Tipikus végrehajtása a bejelentkezés során környezeti változók beállítása.

alias [-tx] [Név[=Érték]] ...
Argumentum nélkül az alias parancs kiírja a helyettesítőnevek listáját Név=Érték formátumban. Argumentumot megadva beállítja a Név=Érték formában megadott hozzárendelést.

Példa:

$ alias dir=ls

hatására a dir parancs is kiírja egy könyvtár tartalmát.

Az x kapcsoló hatására az utasítás exportált (azaz az aleljárások számára is elérhető) lesz, illetve kiíráskor csak az exportált helyettesítő neveket írja ki.
A t kapcsoló bekapcsolja a nyomkövetést az adott Névre.

break [n]
Kilép a while, until, for vagy select hurokból. Az opcionális n paraméter mondja meg, hogy egymásba ágyazott hurkok esetén hány szintet lépjen feljebb.

continue [n]
A while, until, for vagy select következő ciklusát kezdi el. Az opcionális n paraméter mondja meg, hogy egymásba ágyazott hurkok esetén hány szintet lépjen feljebb.

eval [Argumentum ...]
Beolvassa az Argumentumokat shell inputként, és az eredményként létrejövő parancso(ka)t végrehajtja. Ezzel az utasítással kétszer történik meg az Argumentumban található speciális karakterek kiértékelése.

exit [n]
A shell befejezi futását és az n értékkel tér vissza. Ha nem adunk meg visszatérési értéket, akkor az az utolsó végrehajtott parancs értékével tér vissza.

getopts OpcióString Név [Argumentum ...]
Lellenőrzi a shell parancs Argumentumát (pozíciós paramétereit) az opciók szempontjából. Opció a + vagy a - jellel kezdődő betű (vagy szó). Ha az argumentum nem plusz vagy mínusz jellel kezdődik, vagy a -- jel fordul elő, azon túl nem keres opciót.

Az OpcióString tartalmazza azokat a betűket, amit a getopts parancs opcióként felismer. Az adott betű utáni kettőspont azt jelzi, hogy annak az opciónak argumentuma van. Az opció argumentumát vagy közvetlenül az opció után, vagy attól szóközzel elválasztva kell megadni. A getopts parancs a soron következő opcióbetűt a Név változóba helyezi, amennyiben az opciót a + (vagy -) jel előzte meg. A következő argumentum pozícióját az OPTIND változó, az adott opció argumentumát az OPTARG változó tartalmazza.

let Kifejezés ...
Kiértékeli a megadott atritmetikai kifejezést. Nulla értékkel tér vissza, ha az utolsó kifejezés értéke nem nulla, máskülönben eggyel.

pwd
Kiírja az aktuális könyvtárat.

read [-prsu[n]] [Név?Prompt] [Név ...]
Beolvas egy sort a standard bemenetről és szavakra bontja a mezőelválasztó karaktereket definiáló IFS környezetváltozó alapján. A sor elejére kiteszi a Promptot, és a Név változóba olvassa a sort. Az r kapcsoló hatására szavakat az egymás után felsorolt Név változókba teszi, és a sorvégi fordított törtjelet nem értelmezi folytatósor jelzésre. Ha nem adunk meg nevet, a sort a REPLY változóba olvassa be. A visszatérési érték nulla, kivéve ha file vége jelet olvas be. A p kapcsoló csőből olvas.

return [n]
A shell függvény futását lezárja és a hívó eljárásba adja vissza a vezérlést n visszatérési értékkel.

set [+-aefhkmnopstuvx] [+-o Opció ]... [+-A Név ] [Argumentum...]
A shell különböző paramétereit állítja. A következő főbb parancsokat használhatjuk:

-n Beolvassa és leellenőrzi a parancsokat, de nem hajtja őket végre.
-o Az utána megadható, leggyakrabban használt opciók a következők:

ignoreeof: a shell nem lép ki a file vége karakterre, csak az exit parancsra;

noclobber: megakadályozza hogy a átirányítás hatására már létező állományokat felülírjon a shell.

-u A helyettesítés során hibának értelmezi, ha egy változó értéke nincs beállítva.
-v Kiírja a végrehajtandó parancsot ahogy beolvassa.
-x Kiírja a végrehajtandó parancsot kifejtés után ahogy végrehajtja.
- Kikapcsolja az x és v kapcsolók hatását.
-- A kapcsolók feldolgozásának végét jelzi. Az utána következő argumentum már kezdődhet minusz jellel anélkül, hogy azt a shell opciónak értelmezné.

Amennyiben a fenti kapcsolókat mínusz helyett plusz jellel adjuk meg, akkor az kikapcsolja az adott kapcsoló hatását. A kapcsolók aktuális beállítását a - környezetváltozó tartalmazza.

shift [n]
Átszámozza a pozíciós paramétereket n+1-től kezdve 1, 2 ...-re (kidobja az n elsőt a listából).

ulimit [-HSacdfmst] [Limit]
Beállítja, vagy (ha nem adjuk meg a Limitet) megmutatja az erőforrás erőforrás határokat.

-a Kilistázza az összes határértéket.
-c A core dump (futási hiba esetén a program memóriaképe a core állományba másolódik, és ezt a dbx paranccsal megvizsgálhatjuk) maximális mérete 512 byte-os egységekben.
-d Az adatmezőnek fenntartott hely maximális mérete kbyte-okban.
-f Az aleljárások által kiírható maximális állománynagyság 512 byte-os blokkokban.
-m A felhasználható fizikai memória nagysága kbyte-okban.
-s A stack területstack terület legnagyobb mérete kbyte-okban.
-t Az eljárás által felhasználható maximális rendszeridő másodpercben.

umask [Mask]
Az újonnan létrehozott állományok alap védelmi beállítását szabályozza.

unalias Név ...
Kiveszi a felsorolt Neveket az alias listából.

unset [-f] Név ...
A felsorolt Nevekhez tartozó értékeket és jellemzőket
kitörli.

Aritmetikai Kifejezések

Egész típusú számolásokat a let speciális parancs segítségével hajthatunk végre. A kiértékelés integer, az aritmetikai kifejezések a C nyelv szintaxisát, prioritási sorrendjét és csoportosítási szabályait követik. A let parancson kívül megengedett a dupla zárójel (azaz a (( ... )) ) használata.

Parancs eredményének helyettesítése

Egy parancs kimenetét felhasználhatjuk egy másik parancsban is. Hagyományosan ezt a fordított aposztrófokkal lehet elérni, de a bash shellben használható még a $( Parancs ) alak is.

Állománynév helyettesítés

A parancs minden szavát a shell leellenőrzi a * ? [...] , karakterek szempontjából. Amennyiben ilyet talál, akkor a szót mintának tekinti, és behelyettesíti abc sorrendben a mintának megfelelő állománynevekkel. Ha nem talál egy állománynevet sem, akkor változatlanul hagyja a szót.
A .-tal kezdődő állományneveknél expliciten ki kell tenni a pontot a minta elejére, különben a shell nem helyettesíti be azokat.
Lehetőleg ne adjunk olyan állomány és könyvtárneveket, melyek csillagot, kérdőjelet vagy szögletes zárójeleket tartalmaznak, vagy mínusz jellel kezdődnek.

A tilde helyettesítés

Az alias helyettesítés után a shell megvizsgál minden szót, hogy nem ~ jellel kezdődik-e. Az utána a / jelig következő szót a shell megnézi, hogy előfordul-e a /etc/passwd állományban felhasználói névként. Ha igen, akkor az adott felhasználó bejelentkezési könyvtárát helyettesíti be a szó helyére.
Amennyiben a ~ / jelet közvetlenül megelőzi, akkor a HOME környezetváltozó értékére helyettesítődik.

Paraméter helyettesítés

A paraméter egy azonosító, a *, @, #, ?, -, $, ! karakterek valamelyike, illetve egy vagy több számjegy lehet. A számjegyes paraméterek az ún. pozicionális paraméterek, melyek egy shell hívásakor a shellnek átadott argumentumokat tartalmazzák a megadott sorrendben. A speciális karakteres paraméterek a shell által használt és általában beállított paraméterek.
A paramétereknek általában értékük és beállított tulajdonságaik vannak.
A bash shell támogatja az egy dimenziós tömbök használatát. A tömb egy elemére annak indexével (szögletes zárójelek közti aritmetikai kifejezés) hivatkozunk. Értéket egy tömbnek a set -A paranccsal adhatunk. A tömb indexe 0 és 512 közötti érték lehet. E határok közt a shell automatikusan létre is hozza a tömböt. Ha egy tömbre index nélkül hivatkozunk, az a 0. elemét jelöli.
Egy paraméter értékét megadhatjuk még egyszerű hozzárendeléssel:

$ Név=Érték

formában is. Amennyiben -i (egész) típusúnak állítottuk be a Név változót, akkor az Érték egy aritmetikai kifejezés is lehet, amit a shell kiértékel. A pozicionális paramétereknek a set speciális paranccsal adhatunk értéket. Ha scriptet hívunk meg, akkor a $0 a hívó parancs neve, $1, $2, ... pedig az átadott argumentumok. A $* és a $@ az összes átadott argumentumot jelenti.

A shell a következő helyettesítéseket hajtja végre:
- ${Paraméter} A shell beolvassa az összes két kapcsos zárójel közti karaktert egy szóként, mégha kapcsos zárójeleket vagy metakaraktereket tartalmaz is. Amennyiben definiálva van ilyen változó, annak értékét helyettesíti be. A kapcsos zárójeleket elhagyhatjuk, ha nem kell a változó neve után közvetlenül egy betűt, számot, vagy aláhúzás karaktert illeszteni, vagy ha a paraméternek indexet adunk. Az egy számjegynél nagyobb pozicionális paramétereket is kapcsos zárójelbekell tenni.
- ${#Paraméter} A Paraméter értékének a hosszát helyettesíti be.
- ${#Azonosító}[*] A tömbben található elemek száma.
- ${Paraméter:-Érték} Ha a Paraméter létezik, és nem nulla az értéke, akkor azt helyettesíti be, különben az Értéket.
- ${Paraméter:=Érték} Ha a Paraméter nem létezik, vagy nulla az értéke, akkor az Értékre állítja be, és ezután helyettesíti be.
- ${Paraméter:?Érték} Ha a Paraméter létezik, és nem nulla az értéke, akkor azt helyettesíti be, különben kiírja az Értéket és kilép a shellből.
- {${Paraméter:+Érték} Ha a Paraméter létezik, és nem nulla az értéke, akkor az Értéket helyettesíti be, különben semmit nem helyettesít be.
- $# A shellnek átadott pozicionális paraméterek száma.
- $- A shell hívásakor bekapcsolt opciók.
- $? Az utoljára végrehajtott parancs visszatérési értéke. A legtöbb parancs sikeres végrehajtáskor 0 értékkel tér vissza.
- $$ A shell processz-száma (PID). Leggyakoribb alkalmazása egyedi állománynév generálása: pl. a /tmp/temp.$$ a processz egyedi számával ellátott állománynevet jelenti.
- $_ Az előző parancs utolsó argumentuma.
- $! A háttérben utoljára elindított eljárás processz-száma.
- $ERRNO A hibakóddal utoljára visszatért eljárás hibakódja.
- $PWD Az aktuális munkakönyvtár.
- $RANDOM Minden híváskor egy 0 és 32767 közötti "véletlen számot" generál. A kezdőértéke beállítható.
- $SECONDS A shell meghívása óta eltelt időt írja ki másodpercekben. Ha kezdőértéket adunk neki, onnan számolja az időt.

A környezeti változók beállítására következzen egy mintaként használható .profile állomány:

umask 22
export PATH=$PATH:/bin:/usr/local/bin:/usr/X11/bin:.
PS1='$LOGNAME'@`hostname`' $ '
export TERM=vt100
export PS1
if [ -z "$DISPLAY" ]
then
    export DISPLAY=`who am i | awk '{l=length($6); print substr($6,2,l-2)":0.0"}'`
else
    if [ "$DISPLAY" = ":0.0" ]
    then
        export DISPLAY=":0.0"
    else
        export DISPLAY=`who am i || awk '{l=length($6); print substr($6,2,l-2)":0.0"}'`
    fi
fi
alias ls='ls -gF '

Az állományban először beállítjuk az ú.n. umask értékét (azaz a 755-ös alap védelmi kódot), majd a PATH, PS1 és TERM környezeti változókat (figyeljük meg, hogy a PS1 értéke egy shell parancsot is tartalmaz!) Ezután egy dupla if feltételvizsgálattal megállapítjuk, hogy honnan jelentkeztünk be (helyi gépről vagy a hálózaton keresztül), és ennek megfelelően beállítjuk az X11 Window által használt DISPLAY változó értékét (ez adja meg az X11 ablakokat megjelenítő grafikus terminál nevét). Az állományt néhány alias definícióval zárjuk: az ls parancs a csoportot is fel fogja tüntetni a hosszabb file listákban.

Példa: Nézzük a következő parancsállományt, amely helyi hirdetőtáblaként működtethető:

#!/bin/bash
PS3="Válasszon> "
select ans in "exit" `ls -d /usr/local/info/*/* \
                              | sed "s//usr/local/info/$.*$\.news/\1/"`
    do
    if [[ $ans = exit ]]
    then
        exit
    fi
    more /usr/local/info/$ans.news
    echo "Nyomjon ENTER-t a folytatáshoz ... "
done

Az állomány első sorában a #! megjegyzés után következik a parancsot futtató shell neve. A második sorban beállítjuk a select parancs által használt PS3 prompt értékét. A hirdetőtábla a /usr/local/info könyvtár alkönyvtáraiban elhelyezkedő .info végződésű állományokból áll: egy-egy tétel címe megegyezik az állomány nevével. A select parancs argumentumában az automatikusan felépítik a pillanatnyi listát (figyeljük meg a folytatósorok használatát a sorvégi \ karakterrel), amiből aztán a felhasználó a kívánt sorszám beütésével választhat. Az ans változó a kiválasztott tétellel tér vissza, amit aztán a do ciklusban elhelyezkedő more utasítás jelenít meg. A ciklus az ans változó exit értékéig ismétlődik.

A for ciklus használatára példa a következő parancsállomány:

#!/bin/bash
for file in ls *.c
do
cp -i $file $file.old
echo $file
done

A parancssorozat az adott könyvtárban található minden .c végződésű állományból másolatot készít, aminek neve az eredeti név .old-dal kiegészítve.

Állomány megkeresése a könyvtárstruktúrában

Állományokat a find parancs segítségével kereshetünk meg a könyvtárrendszerben. Például a

$ find . -name test.c -print

parancs az aktuális könyvtártól lefelé megkeresi az összes test.c állományt, és a nevüket kiírja a képernyőre.

Ha nem tudjuk a teljes nevet, csak azt hogy c-re végződik, akkor a

$ find . -name '*c' -print

parancsot használva a find az aktuális könyvtártól lefelé megkeresi az összes c végződésű állományt, és a nevüket kiírja a képernyőre.

A parancs általánosabb alakja:

$ find KiindulásiKönyvtár -name Állomány -exec Parancs

a KiindulásiKönyvtárból elindulva a könyvtárstruktúrában lefelé keresi a megadott nevű Állományt és végrehajtja rá a megadott Parancsot. A find sokoldalú parancs, részletes leírását pl. a man find utasítással kérhetjük elő.

Példák mentésre:

teljes mentés:

export DATUM=linux1.teljes.`date "+%y%m%d"`
ssh backup@nagylinux "mkdir $DATUM"
cd /home/projects
touch teljes_mentes
for dir in `ls -1`
do
tar -zcvf - $dir | ssh backup@nagylinux "cd $DATUM; split --bytes=690m - $dir.tgz."
done

export DATUM=linux1.teljes.`date "+%y%m%d"`/users
ssh -1 backup@nagylinux "mkdir -p $DATUM"
cd /home
for dir in `ls -1 | sed '/projects/d'`
do
tar -zcvf - $dir | ssh backup@nagylinux "cd $DATUM; split --bytes=690m - $dir.tgz."
done

heti mentés:

cd /home
touch uj_heti_mentes
export MENTES='Heti/linux1.w'.`date "+%y%m%d"`.tgz
echo $MENTES
find . -newer regi_heti_mentes -type f -print >/tmp/uj_heti_menteslista
tar -zcvf - -T /tmp/uj_heti_menteslista | ssh backup@nagylinux "cat >$MENTES"
mv uj_heti_mentes regi_heti_mentes

törlés:

find Napi -type f ! -newer `ls -dt Heti/* | head -1 ` -exec rm {} \;

Állományok feldolgozása

Reguláris kifejezés: speciális (jelentésű karakterek)

^ sor eleje

$ sor vége

. tetszőleges karakter

* az előző karakter tetszőleges (akár nulla) számú előfordulása

\< szó eleje

\> szó vége

$...$ csoportosítás (helyettesítésnél érdekes)

\n helyettesítésnél: az n. csoport értéke

/^$ab[^ ]*k$.*$aj.*o$/jo is az \1 de nem a \2/ \1 lehet ablak, ablakok, ablak is van a hazban a k(ert fele), \2 lehet ajto, ajato(llah)

[] a [] közt felsorolt karakterek bármelyike

[a-zA-Z] betűk

[0-9] számok

[a-zA-Z0-9] betűk vagy számok

[^l] nem l karakter

\^ a ^ karakter

\/ a / jel

Unix parancsok

A UNIX operációs rendszerben sok parancs az állományok feldolgozását: kifejezések megkeresését, gyors szerkesztését (pipe-ot használva), rendezését, ismétlődések kiszűrését teszi lehetővé. A továbbiakban ezeknek a parancsoknak a részletes ismertetésével foglalkozunk.
A UNIX operációs rendszerben a grep parancs szolgál arra, hogy állományokban megadott karaktersorozatokat keressünk. A sed parancs a kimenet szűrőszintű szerkesztésére ex-- ill. vi--szerű utasításokkal ad lehetőséget.
A UNIX általános célú állomány feldolgozó programja az awk, amely megadott mintájú sorokon utasításokat hajt végre.
Az állományok bizonyos szempont szerinti sorrendbe tételére a sort parancs szolgál.
Az univerzális javítókészlet szerepét a perl tölti be.

A grep parancs ismertetése

A grep szolgál arra a UNIX operációs rendszerben, hogy állományokban megadott karaktersorozatokat keressünk. A grep családjába tartozik még az egrep és a fgrep parancs is. A karaktersorozat tartalmazhat általános helyettesítő karaktereket is (l. ed, vi, sed parancsok). A parancsnak a kapcsolókon kívül két argumentuma van: az első a keresett minta, a második a állományok listája, amiben keressük. Az utóbbi hiányában a standard bemenetről olvassa be az állományt (szűrőként is alkalmazhatjuk). Ha csak egy állományt adunk meg, akkor csak a mintát tartalmazó sorokat írja ki, különben eléjük rakja annak az állománynak nevét is, amiben a keresett minta előfordul.

A keresendő minta megadásánál vigyázni kell arra, hogy a shell által speciálisan kezelt karaktereket (', *, [, \, ", (, ),) levédjük. Ha a minta nem egy összefüggő karaktersorozat, akkor azt aposztrófok (vagy macskakörmök) közé kell tenni. A főbb helyettesítő karakterek a $, mely a sor végét, a ^, mely a sor elejét, a ., mely egy tetszőleges karaktert, a *, mely az utolsónak megadott karakter tetszőleges számú megjelenését jelöli és a [] pár, mely azt határozza meg, hogy a karakternek a zárójelek közti értékek valamelyikét kell felvennie. Itt megengedett pl. az [a-z] használatával egy egész tartomány kijelölése is. A zárójelben egy kifejezés előtti azt jelzi, hogy azt az értéket nem veheti fel a helyettesítendő karakter. A -e kapcsoló használatával lehetőség van több minta megadására is.

A grep parancs használatakor a következő korlátozásokat célszerű szem előtt tartani:

a sorok maximálisan 2048 karakter hosszúak lehetnek, a hosszabb sorokat a grep betördeli.
A paragrafusok (ld. -p kapcsoló) maximális hossza 5000 karakter.
A bemenő állomány nem tartalmazhat NULL karaktert, és új sor karakterre kell végződnie.

A grep kapcsolói:

-c Azt írja ki, hogy hány sort talált, mely tartalmazta a mintát.

-e Minta Egy vagy több keresendő mintát lehet megadni. Igen hasznos, ha a Minta a - (mínusz) jellel kezdődik. A mintákat egymástól újsor karakterrel kell elválasztani. A mintákat a grep a -E és -F kapcsolók hiányában egyszerű reguláris kifejezés értelmezi. Több megadott minta esetén minden olyan sort kiír, amelyik legalább az egyik mintát tartalmazza. A -e kapcsoló el is hagyható, de ilyenkor a Mintának a grep parancs első argumentumának kell lennie. A kapcsoló többször is kiadható, és ekkor a mintákat nem kell az újsor karakterrel elválasztani.

-F Mindegyik megadott mintát szó szerint, és nem reguláris kifejezésként értelmezi, ezért sokkal gyorsabban lefut. Ha a kapcsoló egy adott rendszerben nem létezik, akkor a grep helyett az fgrep parancsot használva ugyanezt a funkciót megkapjuk..

-f Állomány Megadja a keresési mintákat tartalmazó állomány nevét. Az Állományban minden mintának új sorban kell állnia.

-i Az összehasonlítás során nem tesz különbséget a kis- és nagybetuk között.

-l Csak azon állományok nevét sorolja fel, amelyekben a megadott kifejezés megtalálhato.

-n Minden sor elé kiírja, hogy az állomány hányadik sorában található a megadott minta.

-v A megadott mintát nem tartalmazó sorokat írja ki.

Példák:

1. A proba állományban keressük meg azokat a sorokat, melyek betűvel kezdődnek:

$ grep '^[a-zA-Z]' proba

A mintában szereplő (sor eleje) jel mögötti kifejezés kiválaszt minden betűt, mely abc sorrendben a és z illetve A és Z közé esik -- azaz minden kis és nagy betűt.

2. A proba állományból írjunk ki minden olyan sort, mely vagy az abc vagy a xyz karaktereket tartalmazza:

$ grep -e 'abc' -e 'xyz' proba

vagy

$ grep 'abc
> xyz' proba

A sed pipe szerkesztő

A sed (streamline editor) egy csö szűrőszintű szerkesztésére szolgál.
A szerkesztés során lehetőség van kiválasztani azokat a sorokat, melyekre a szerkesztést el akarjuk végezni, és csak azokat módosítani.
A sed nagyon hasonlít az ed szerkesztő családra (ld. vi), és ennek megfelelően a parancsok általános alakjában meg lehet adni a tartományt (sorok), melyekre a parancs vonatkozik, egy parancsot, illetve az azt módosító kapcsolókat.
A sed beolvassa a megadott állományokból (standard bementről) a sorokat a minta munkaterületre, végrehajtja azon a megadott parancsokat sorjában, és végül kiírja a standard kimenetre. Ezek után letörli a minta munkaterületet,minta munkaterület és ugyanezt elvégzi a következő sorral. Néhány parancs egy másik munkaterületre (tároló) el tudja menteni a minta munkaterületet vagy annak egy részét, hogy a későbbiekben azt újra felhasználhassa.
Ha a sed parancs nem tartalmaz címtartományt, akkor minden sorra vonatkozik, különben csak a kijelölt sorokra. A cím lehet a sor száma, a jel (a bemenet utolsó sorát jelöli), vagy egy reguláris kifejezés, mely kijelöli azt a sort, amellyel a mintája illeszkedik. A szokásos reguláris kifejezésektől a sed megenged néhány eltérést:
- A pont minden karaktert helyettesít, még a nem sorvégi újsor karaktert is
- A cím állhat nulla, egy vagy két címből. Ha nincs megadva cím, a parancs minden sorra vonatkozik. Amennyiben egy szám (illetve a jel), vagy egy reguláris kifejezés van megadva, az utána jövő parancs a megadott számú sorra, illetve a reguláris kifejezéssel megegyező sorra vonatkozik. Ha két számot adunk meg vesszővel elválasztva, akkor a két sorszám között minden sorra vonatkozik a parancs. Amennyiben a második szám kisebb vagy egyenlő az elsőnél, akkor csak az első számmal megegyező sorszámú soron végzi el a parancsot.
- A sed a megadott parancsokat vagy a standard bementről veszi (első argumentum, vagy -e kapcsoló), vagy egy állományból (-f kapcsoló). Egyszerre összesen 99 parancsot lehet megadni.

A sed kapcsolói a következők:

-e Utasítás      A megadott Utasítás alapján dolgozza fel a szöveget. Amennyiben nem használjuk a -f kapcsolót, és csak egy utasítást adunk meg, nem kell kitenni a kapcsolót.
-f Állomány    Az utasításokat tartalmazó Állomány nevét adja meg.
-n                    Nem írja ki a standard kimenetre a szerkesztés eredményét (csak az Utasításban szereplő külön parancs esetén). Ezzel lehet elérni, hogy a sed ne írjon ki olyan sorokat, melyeket nem szerkesztünk.

A sed parancsai

A sed parancsok sokszor valamilyen szöveget tartalmaznak. Az a+, c+ vagy i+ parancsok esetén egy sornál hosszabb szöveget is beírhatunk, ha az utolsó sor kivételével mindegyik egy fordított törtjelre végződik. Mivel a parancsállományban a sed figyelmen kívül hagyja a sor elején álló szóköz és tabulátor karaktereket, azokat a megadott szövegben a fordított törtjellel kell levédeni.
A parancsok előtt zárójelben szerepel, hogy hány címet fogad el az adott parancs:
- (1) a Szöveg A következő sor beolvasása előtt a Szöveget kiírja a kimenetre. Az a parancs után fordított törtjelet kell tenni, és a Szöveget új sorba írni.
- (2)b[Cimke] A :Cimkével kezdődő sorra ugrik a parancsállományban. Ha nem adunk meg Cimkét, a parancsállomány végére ugrik.
- (2)c Szöveg Letörli a minta munkaterületet, és kiírja a Szöveget a kimenetre. Címtartomány megadása esetén csak a tartomány végén írja ki a Szöveget. Az a parancshoz hasonlóan itt is a c parancs után fordított törtjelet kell tenni, és a Szöveget új sorba írni.
- (2)d Letörli a minta munkaterületet.
- (2)D A minta munkaterület elejéről az első új sor karakterig töröl.
- (2)g A minta munkaterületet letörli, és a tároló munkaterületet tölti át.
- (2)G A tároló munkaterület tartalmát a minta munkaterület végére illeszti.
- (2)h A tároló munkaterületre bemásolja a minta munkaterület tartalmát.
- (2)H A minta munkaterület tartalmát a tároló munkaterület végére illeszti.
- (1)i Szöveg A Szöveget a kimenetre teszi, mielőtt a minta munkaterület tartalmát kiírná. Az a parancshoz hasonlóan itt is az i parancs után fordított törtjelet kell tenni, és a Szöveget új sorba írni.
- (2)l A minta munkaterületet kiírja a standard kimentre úgy, hogy a nem nyomtatható karaktereket 4 számjegyű hexadecimális formában írja ki. A hosszú sorokat betördeli (folytatósor esetén az előzo sor végére egy fordított törtjelet tesz). Igen hasznos, ha olyan állományunk van, melyben hosszú (például 2048 karakternél hosszabb) sorok vannak, mivel azokat nem minden szövegszerkesztő képes kezelni.
- (2)n A minta munkaterületet a standard kimenetre írja, és annak helyére beolvassa a következő sort.
- (2)N A feldolgozandó állomány következő sorát a minta munkaterülethez fűzi egy újsor karakterrel elválasztva, és megváltoztatja az aktuális sorszámot. Olyan minták keresésekor célszerű alkalmazni, melyek két (vagy több) egymás utáni sorban lehetnek.
- (2)p A minta munkaterületet a standard kimenetre írja.
- (2)P A minta munkaterület elejét az első újsor karakterig a standard kimenetre írja.
- (1)q A parancsállomány végére ugrik, de nem indít el új ciklust, hanem kilép.
- (2)r Állomány Beolvassa az Állomány tartalmát, és a standard kimenetre teszi a következő sor beolvasása előtt. Az Állománynak a parancssor végén kell állnia, és pontosan egy elválasztó karakter (szóköz vagy tabulátor) lehet előtte.
- (2)s/Minta/Helyettesítés/Kapcsolók A munkaterületen levő, a megadott Mintával egyező karaktersorozatot a Helyettesítés karaktersorozatra írja át. Ha nem adjuk meg a g kapcsolót, csak az első előforduló legnagyobb mintát cseréli le. A helyettesítés szintaxisa megegyezik az ed és vi szerkesztőknél leírtakkal. A következő kapcsolókat adhatjuk meg (egyszerre többet is):
- [g] Az összes előforduló, a megadott mintának megfelelő karaktersorozatot lecseréli.
- [n] Csak a mintának megfelelő n. karaktersorozatot cseréli le.
- [p] Kiírja a minta munkaterületet, ha sor került a helyettesítésre.
- w Állomány A minta munkaterületet az Állományba írja, ha sor került a helyettesítésre. A munkaterületet az Állomány végéhez fűzi hozzá (vagy ha az nem létezik, akkor létrehozza).
- (2)tCimke A :Cimke sorra ugrik a parancsállományban, amennyiben a helyettesítő parancs hatására változtatás történt a munkaterületen. Ha nem adunk meg Cimkét,cimke a parancsállományvégére ugrik.
- (2)w Állomány A munkaterületet az Állomány végére fűzi. Az Állomány a parancssor végén kell, hogy álljon, és pontosan egy elválasztókarakter előzi meg.
- (2)x Kicseréli a minta és a tároló munkaterület tartalmát.
- (2)y/Minta1/Minta2/ A Minta1-ben felsorolt karaktereket lecseréli a Minta2-ben felsoroltakkal. A két mintában a karakterek számának meg kell egyezni.
- (2)!sed-parancs A megadott sed parancsot azokra a sorokra alkalmazza, melyeket a címkiválasztás nem jelölt ki.
- (0):Cimke A b és t parancsok számára egy cimkét ad meg a parancsállományban. A Cimke legfeljebb 8 karakterből állhat.
- (1)= Kiírja az aktuális sor számát a standard kimentre.

Példák:

1. Teljes csere végrehajtása: átírunk minden alma stringet eper-re a BemenoAllomany állományban. A kimenetet az UjAllomanyba írjuk:

$ sed "s/alma/eper/g" BemenoAllomany UjAllomany

2. A pr parancs által előállított lap sorszámokat zárójelbe szeretnénk tenni, és úgy kinyomtatni a BemenoAllomanyt:

$ pr BemenoAllomany | sed "s/Page\s*$[0-9]*$/(\1)/" | lpr

Ez az utasítás a Page szót tartalmazó, és tetszőleges számú "space" jellegű karakter után következő számra végződő sorokat cseréli le, úgy hogy a számot írja csak ki zárójelben (az \1 jelöli az első, $ - $ párral kijelölt résszel egyező mintát).

3. Ha csak a keresem szót tartalmazó sorokat szeretnénk megjeleníteni a BemenoAllomanyban, akkor a

$ sed -n "/keresem/p" BemenoAllomany

A -n kapcsoló miatt nem íródik ki semmi olyan a kimenetre, amire nem szólítottuk fel a sedet. Jelen esetben ez a p parancs (az utasítás helyett a grep parancsot is használhattuk volna).

Állományok sorrendbe rendezése: a sort utasítás

A sort állományok bizonyos szempont szerinti sorrendbe tételére, illetve a már rendezett állományok helyes sorrendben való összefűzésére szolgál.
A parancs az argumentumában megadott állománynevet (ennek hiányában a standard inputot) rendezi, és az eredményt a standard kimenetre írja (kivéve ha a -o kapcsolóval megadjuk a kimeneti állomány nevét). Több bemeneti állománynevet is megadhatunk, ilyenkor a sort parancs összefűzi őket, és az így kapott állományra végzi el a rendezést. Az alapértelmezésbeli rendezés az (angol) abc sorrend szerint történik, ill. LANG környezeti változó szerint.
A rendezés mezők és oszlopok kijelölésével történhet. A mező az elválasztó karakterek (ez általában a szóköz és a tabulátor) közötti karaktersorozat. Az elválasztó karaktert a -t kapcsolóval adhatjuk meg. Az oszlop a mezőn belüli karakterpozicíó. A mezo és/vagy az oszlop számát rendezési kulcsnak hívjuk.
A sort parancs a rendezést a megadott kulcsok sorrendjében végzi, azaz először az első kulcs szerint rendez, és a kulcson belül megegyező sorokat a második megadott kulcs alapján rendezi tovább (stb.).
A sort kapcsolói:
- -A Az ASCII szekvencia szerint végzi el a rendezést (az alapértelemzést a helyi nyelvre is át lehet állítani).
- -b Figyelmen kívül hagyja a sor elején álló szóközöket vagy tabulátorokat az oszlopok kiszámolásánál.
- -d ABC sorrend szerint végzi a rendezést. Csak a betűk, számok és a szóközök számítanak.
- -f Rendezés előtt az összes kisbetűt nagyra cseréli.
- -i Figyelmen kívül hagyja az összes nem nyomtatható karaktert az összehasonlítás során.
- -kKulcsDefiníció    Egy keresési kulcsot definiál, a következő formátumban:
  
  [KezdőMező][.KezdőOszlop][Módosító][,[VégMező][.VégOszlop][Módosító]]
  
  A szögletes zárójelek azt jelzik, hogy nem kötelező megadni a bennük levő számokat. A rendezés a KezdőMező KezdőOszlopa és a VégMező Végoszlopa közötti karakterek szerint történik. A Módosító a b,d,f,i,n és r értékek valamelyike lehet. Hatásuk megfelel az azonos betűvel jelölt kapcsolókénak. A fenti mennyiségek alapértékei: a KezdőMező a sor eleje, a KezdőOszlop az első oszlop a mezőben, a VégMező az utolsó mező, és a VégOszlop a mező utolsó oszlopa. A
  
  -k 3.2,3r
  
  kapcsoló olyan rendezést jelent, melyben a 3. mező 2. pozíciójától a 3. mező végéig (nincs kitéve a VégOszlop) folyik a rendezés, fordított sorrendben (ld. -r kapcsoló). A fenti definíció megadható a -k kapcsoló használata nélkül is, ha pl. a KezdőMező elé plusz, a VégMező elé mínusz jelet írunk. Ilyenkor a + kapcsoló jelzi az átugrandó mezők számát, míg a - kapcsolóval adjuk meg azt a legutolsó mezőt, amelyik még számít. Az előző példa ezzel a módszerrel ezért ilyen:
  
  +2.1 -3r
  
  -m     Több, már rendezett állományt fűz össze egy rendezett állományba.
  
  -n     A számokat tartalmazó mezőket a számértékük szerint rendezi. Mivel az ASCII sorrend szerint pl. a 10 előbb van, mint a 2 (a 2-es számjegyet megelőzi az 1), a numerikus kifejezéseket csak így lehet sorbarendezni. A numerikus mező tetszőleges számú szóközzel és tabulátorral kezdődhet, tartalmazhat előjelet, tizedes értékeket, az ezreseket elválasztó jelet. Minden más jel a felhasználó számára is érdekes eredményt szolgáltat.
  
  -o Állomány    A rendezés eredményét a megadott Állományba irányítja. Megadhatjuk itt ugyanazt az Állománynevet is, amelyiket éppen rendezünk.
  
  -r    Megfordítja a rendezés sorrendjét.
  
  -tKarakter A megadott Karaktert tekinti a sort a mezőket elválasztó karakternek.
  
  -u Ha a rendezés során több sort egyenértékűnek talál a sort, akkor a -u kapcsoló hatására csak egyet ír ki.
  
  -T Könyvtár Az összes, a rendezés során használatos átmeneti állományt a megadott Könyvtárba helyezi. Akkor célszerű használni, ha nagy állományt rendezünk, és a mi könyvtárunkban (file rendszer) kevés a hely.

Példák:

a következő minta.txt állományt különböző szempontok szerint:

+Kalmanka 16
lajoska 4
Peterke 28
Jozsika 12
lajoska 34
peterke 28
Sanyika 111

1. A legegyszerűbb sorbatétel a következő:

$ sort minta.txt

+Kalmanka 16
Jozsika 12
Peterke 28
Sanyika 111
lajoska 34
lajoska 4
peterke 28

A rendezés először a jeleket, aztán a nagybetűket, utána a kisbetűket veszi abc sorrendben. Ha lexikográfiai rendezést hajtunk végre a -d kapcsolóval, akkor az figyelmen kívül hagyja a jeleket, így +Kalmanka a Jozsika és Sanyika közé kerül. ASCII rendezés (-A kapcsoló) esetén a jelek a kis és nagybetűk közé kerülnek, és +Kalmanka Sanyika és lajoska köze kerül.

2. A következő parancs lexikografikus sorrendbe teszi az állományt úgy, hogy nem tesz különbséget kis- és nagybetű között (ld. -f kapcsoló), és az ismétlődő sorokat csak egyszer írja ki (ld. -u kapcsoló):

$ sort -d -f -u minta.txt

Jozsika 12
+Kalmanka 16
lajoska 34
lajoska 4
peterke 28
Sanyika 111

Most nem teszünk különbséget kis- és nagybetű között, ezért hiányzik a Peterke 28 sor is.

3. Rendezzük most az állományt a második mező (számok) szerint. A következő parancs abc sorrend szerint rendez, azaz minden 1-gyel kezdődő megelőzi a 2-vel kezdődőket:

$ sort +1 minta.txt

Sanyika 111
Jozsika 12
+Kalmanka 16
Peterke 28
peterke 28
lajoska 34
lajoska 4

4. A következő parancs a számsorrend szerinti rendezéshez szolgál:

$ sort +1 -n minta.txt

lajoska 4
Jozsika 12
+Kalmanka 16
peterke 28
Peterke 28
lajoska 34
Sanyika 111

Amikor a mezőket egymástól nem szóközök, hanem például kettőspontok választják el, mint pl. a /etc/passwd állományban, akkor meg kell adni az elválasztókaraktert. A rendszer összes felhasználójáról a sort -t: +4 /etc/passwd paranccsal kapunk a nevek szerinti abc sorrendben listát (ha a rendszergazda nem volt lusta, és beírta a neveket).

Fileok összefűzése

A cat és a paste fájlok soronkénti ill. oszlopokkénti összefűzésére szolgál.

Ismétlődések kiszűrése

A uniq parancs kiszűri az egy állományban található ismétlődő sorokat.

^	sor eleje
$	sor vége
.	tetszőleges karakter
*	az előző karakter tetszőleges (akár nulla) számú előfordulása
\<	szó eleje
\>	szó vége
\(...\)	csoportosítás (helyettesítésnél érdekes)
\n	helyettesítésnél: az n. csoport értéke
/^\(ab[^ ]k\).\(aj.*o\)/jo is az \1 de nem a \2/ \1	lehet ablak, ablakok, ablak is van a hazban a k(ert fele), \2 lehet ajto, ajato(llah)
[]	a [] közt felsorolt karakterek bármelyike
[a-zA-Z]	betűk
[0-9]	számok
[a-zA-Z0-9]	betűk vagy számok
[^l]	nem l karakter
\^	a ^ karakter
\/	a / jel