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.

A shell program fogadja a parancsokat és --- részben átalakítva --- továbbadja azokat az egyes speciális programoknak.

A shellen belül megteremtették a programok összekapcsolásának lehetõségét is, mivel általában minden program innen indul el.

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 file nevét kell írnunk.
Például:

ls -l > filelista Enter
cat filelista Enter
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,átirányításkimenet akkor a >> jelet kell használnunk.

ls > filelista Enter
ls -l >> filelista Enter
cat filelista Enter
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íthajuk.

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' Enter
Itt nincs a keresett karakter Enter
Ebben mar van Enter
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 Enter
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

A 2>&1 parancs segítségével a stderr fájldeszkriptorhoz tartozó kimenetet kezelhetjük.
Vigyázzunk: számít a sorrend!
a.out 2>&1 >tmp
a.out >tmp 2>&1


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ánybakimeneti állományba írja.

Mindez nagy közbülsõ állományoká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 argumentumanké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 (file-t) a nevével futtatunk.

PATH környezeti változóban megadott könyvtárakat sorra végignézi,

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.
linux $ 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 Enter

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 ProgramKimenetiFile Enter

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 & Enter

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évEnter
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

linux $ 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

linux $ 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 Enter

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

kill -9 %2 Enter

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] ParancsEnter
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 Enter

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 Enter

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ó:
A bash shell maga egy interaktív parancsértelmezõ és programmozási nyelv, amely a következõ funkciókat tartalmazza:
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 (l. 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

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).

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 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évelvisszaté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
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 parancsokatt 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.

Újkori cifraság, hogy lehetség van a szóközzel induló paracsokat kihagyni a .bash_history-ból.

A parancsok visszahívására az fc parancs szolgál. Az FCEDIT környezetváltozó értéke az a szövegszerkesztõ, melyet a szerkesztéshez szeretnénk használni, például a vi vagy az emacs.

A parancssor szerkesztését az FCEDIT definiálása nélkül, az EDITOR illetve ennek hiányaban a VISUAL környezetváltozók beállításával is megadhatjuk. Ha a változó értéke emacs, gmacs, vagy vi-ra végzõdik, akkor a megfelelõ parancsszerkesztési mód lép mûködésbe. Általában ezek egyike sincs definiálva, errõl a felhasználónak kell gondoskodnia (például a .profile állományon keresztül).

Az EDITOR és VISUAL környezetváltozók helyett a

set -o vi

, ill. a

set -o emacs

parancsokkal is beállíthatjuk a parancssorok szerkesztését. Ezeket a parancsokat szintén célszerû a .profile állományba beleírni.

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 Lista ;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 Listában felsorolt parancsokat a pozíciós paraméterekre hajtja végre.

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

A select parancs kinyomtatja a standard hibakimenetenstandard hibakimenet 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-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 Listában felsorolt parancs(ok).

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

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

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

Az if parancs végrehajtja az elsõ Listában felsorolt parancsokat, és ha az utolsó nulla visszatérési értéket ad, akkor az utána következõ Listá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 Listát hajta végre.

while Lista ;do Lista ;done

until Lista ;do Lista ;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.programhurok
Az until parancs hasonlóan mûködik, csak a feltételnek nulla értékére lép ki a hurokból.

( Lista )

A Lista 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).

Lista ;

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ó () {Lista} ;

az Azonosítóhoz rendel egy függvényt. A függvény a {} közötti Listá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:


Összetett kifejezéseket ezekbõl a következõképp gyárthatunk (csökkenõ prioritással):

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õlinteraktí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.

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éldául az

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.

export [Név[= Érték]] ...
A megjelölt neveket exportálja. Ezáltal az így kijelölt változók automatikusan átadódnak a shellbõl indított aleljárásoknak is, még ha közben meg is változtattuk értéküket.

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 viszsza, ha az utolsó kifejezés értéke nem nulla, máskülönben eggyel.

print [-Rnprsu[n]] [Argumentum ...]
Kinyomtatja az argumentumokat a standard kimenetre. A kapcsolók jelentése a következõ: az R és r nem hajtja végre az ún. escape szekvenciákescape szekvenciák (++, stb.) kifejtését, az n nem ír ki új sor karaktert a lista végére.
A p kapcsoló csõbe ír, az s kapcsoló hatására pedig az utasítás beleíródik a HISTFILE állományba. Az u kapcsoló segítségével az n számmal megadott állományleíróba írhatunk.

pwd
Kiírja az aktuális könyvtárat. Hatása azonos a print -r - PWD paranccsal.

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, az s kapcsoló hatására a parancs beleíróddik a HISTFILE állományba. Az u kapcsoló segítségével az n számmal megadott állományleíróból olvashatunk.

readonly [Név [=Érték] ] ...
A megadott Nevet csak olvashatónak jelöli meg, és ezáltal a változó értékét nem lehet késõbb megváltoztatni.

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õ parancsokat használhatjuk:

-a Minden további definiált változó automatikusan exportált lesz.
-f Letiltja az állománynév helyettesítést.
-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:
emacs: emacs módban lehet a parancssort szerkeszteni;
vi: a vi beszúrási üzemmódjában hajtja végre a parancssor szerkesztését;
ignoreeof: a shell nem lép ki a file vége karakterre, csak az exit parancsra;
markdirs: minden az állománynévkifejtés eredményeként kapott könyvtárnév végére egy törtvonalat illeszt;
noclobber: megakadályozza hogy a átirányítás hatására már létezõ állományokat felülírjon a shell. Ilyenkor a jellel érthetünk el felülírást;
nolog: megakadályozza, hogy a függvénydefiniciókat a shell a history file-ba mentse. Ha nem adunk meg opciókat, a beállított opciókat írja ki.

-s A pozíciós paramétereket abc sorrendbe állítja.
-t Kilép egy parancs beolvasása és végrehajtása után.
-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.

times
Kiírja a shell, és a belõle indított eljárások által felhasznált rendszer- és felhasználói idõt.

trap [Parancs] [Jel] ...
Beolvassa és végrehajtja a Parancsot ha a shell megkapja a Jelet. A kiadható jeleket a kill -l paranccsal listázhatjuk ki.

typeset [+HLRZfilrtux[n]] [ Név [=Érték]] ...
Beállítja bash:type a shell változók értékeit és típusát.

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.

wait [Job]
Vár a megadott eljárásra (Job), és tudósít futásának befejezésérõl. Ha nem adjuk meg az eljárást, az összes aleljárásunk végére vár. A megadott eljárás visszatérési értékét adja vissza.

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.

Jelölje a MintaLista az egy, vagy több || jellel elválasztott mintát. Ekkor
?(MintaLista) Az adott minták közül bármelyikkel egyezik.
*(MintaLista) Az adott minták egyszer sem, vagy többször fordulnak elõ.
+(MintaLista) Az adott minták egyszer vagy többször fordulhatnak elõ.
@|(MintaLista) Csak az egyik megadott mintával egyezik.
!(MintaLista) Egyik megadott mintával sem egyezik.

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.

Ki- és bemenetek átirányítása

A shell --- még mielõtt végrehajtaná a parancsokat --- lehetõséget biztosít, hogy azok bemenetét és kimenetét átirányítsuk. Az átirányítási parancsokra is végrehajtódik a shell helyettesítése, de csak a kifejtett értékek adódnak át a meghívott programnak.

< File
A File állományból veszi a standard bemenetet.

>File
A File állományba teszi a standard kimenetet. Amennyiben az állomány létezik, felülírja, ellenkezõ esetben létrehozza.

>|File
Ugyanaz, mint a , de a noclobber opció esetén is felülírja a létezõ állományt.

>>File
A File állományba teszi a standard kimenetet úgy, hogy létezõ állomány esetén annak végéhez hozzáír.

<>File
A File állományt írás-olvasásra nyitja meg
standard bemenetként.

<Szó
A shell a Szó elõfordulásáig vagy a file vége jelig olvassa be a standard inputot. Az így keletkezett szöveg lesz a standard bemenet. Amennyiben a Szó bármely karaktere le van védve, akkor a keletkezett szövegen nem történik shell helyettesítés, különben paraméter és parancssor helyettesítés zajlik le. Ha a Szó elé a - karaktert helyezzük, akkor ez a szövegbõl kivágja a sor eleji tabulátorokat.

<&Számjegy
A standard inputot a Számjegy állományleíróból kapja.

>&Számjegy
A standard kimenetet a Számjegy állományleíróba teszi. A fenti jelek elõtti szám az adott számhoz tartozó állományleíró
átirányítását jelöli.

A 2>&1 helyettesítés a 2-es állományleírójú eszközt (standard hibakimenet) az 1-be (standard kimenet) irányítja.

Többszörös átirányítás esetén ügyelni kell a sorrendre. A 1>File 2>&1 kifejezés az 1. állományleírót a File-hoz rendeli, majd a 2. állományleírót az 1.-höz, ami már a File, azaz mindent a File-ba ír. Fordított sorrend esetén a hibakimenetet a standard kimenetre, az eredeti standard kimenetet pedig a File-ba írja.


Helyettesítõ nevek (alias)

Minden parancs elsõ szavát a shell kicseréli, amennyiben azt helyettesítõ névnek (alias) definiáltuk.
A helyettesítõ szöveg (amire a shell az alias-t kicseréli) tartalmazhat bármely létezõ shell scriptet, akár metakarakterekkel is.
Ha aleljárásokban is akarunk használni egy helyettesítõ nevet, azt exportálni kell.

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 vá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 hajta 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ójelbe
kell tenni.

${#Paraméter} A Paraméter értékének a hosszát helyettesíti be. A * illetve a @ Paraméter-nél a pozíciós paraméterek számát adja meg.

${#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.

LINENO A script állományon vagy a függvényen belüli, éppen végrehajtás alatt álló sor száma.

OLDPWD A cd parancs által beállított elõzõ munkakönyvtár.

OPTARG A getopts parancs által feldolgozott utolsó opció argumentuma.

OPTIND A getopts parancs által feldolgozott utolsó opció indexe.

PPID A shell szülõeljárásának processz száma.

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ó.

REPLY A select és a \ep{read speciális parancsok által beállított változó, mely a választ tartalmazza.

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 shell a következõ változókat használja:

CDPATH A cd parancs keresési útvonala.

COLUMNS A shell ennek a változónak az értékét használja a szerkesztési módokban és a select parancs alkalmazásakor az ablak szélességének megállapításához.

EDITOR Ha ennek értéke emacs,gmacs, vagy vi-ra végzõdik, és a VISUAL változó nincs beállítva, akkor a megfelelõ parancsszerkesztési mód lép mûködésbe.

ENV Új shell meghívása elõtt e változó a paraméterhelyettesítéssel kapott állománynevet futtatja le. Általában helyettesítõ nevek és függvények definiálására használják.

FCEDIT Az fc parancs alatt használandó szövegszerkesztõt definiálja.

IFS A shell szóbetördelésére használt elválasztókaraktereket tartalmazza (szóköz, tabulátor, új sor).

HISTFILE A végrehajtott parancsokat tároló állomány neve.

HISTSIZE Értéke adja meg, hogy az utolsó végrehajtott parancsok közül hányat tárol el a shell.

HOME A cd parancs argumentum nélkül ebbe a könyvtárba ugrik. A bejelentkezési eljárás a bejelentkezési könyvtárra állítja az értékét. Ha több gépen dolgozunk, célszerû programjainkat úgy megírni, hogy ne a teljes file-nevekkel, hanem ennek a változónak az értékével hivatkozzunk az állományokra, mivel ezáltal programjaink áttehetõk egyik géprõl a másikra.

LINES A select használja a rendelkezésre álló sorok meghatározására. A select a listát a LINES értékének kétharmadáig írja ki.

MAIL Az új leveleket tartalmazó állomány neve. Ha a MAILPATH változó nincs beállítva, akkor a shell az állomány megváltozását új levél érkezéseként jelzi.

MAILCHECK Értéke meghatározza, hogy a shell milyen gyakran ellenõrizze le a MAILPATH vagyMAIL változókban megadott állományokat. Alapértéke 600 másodperc.

MAILPATH A benne felsorolt, kettõsponttal elválasztott állományneveket ellenõrzi a shell új levél érkezése céljából. Minden állománynév után közvetlenül a kérdõjel után megadhatjuk az üzenetet, amit a shell kiír, ha változás történt az állományban. Az üzenetben a shell elvégzi a paraméter helyettesítést. A megváltozott állomány nevét a $_ változóban tárolja. Az üzenet alapbeállítása: YOU HAVE MAIL IN $_.

PATH A parancsok keresési útvonala. Egymástól kettõsponttal elválasztott könyvtárneveket tartalmaz, melyeknek megadási sorrendjében keresi a shell a kiadott parancsnak megfelelõ állománynevet. A nulla könyvtárnév az aktuális könyvtárat jelöli.

PS1 Az elsõdleges rendszer promptot tartalmazza. Értéke a
prompt kiiratása elõtt átmegy a paraméter helyettesítésen. Ha
felkiáltójelet adunk meg benne, az a parancs sorszámára
helyettesítõdik. Alapértéke a dollár és egy szóköz.

PS2 A másodlagos rendszer prompt. Alapértéke a nagyobbjel és egy szóköz.

PS3 A select parancsban a prompt értéke. Alapértéke a #? és egy szóköz.

SHELL A shell elérési útvonala. (Sok program ezt használja, ha ki akarunk lépni belõle a shellbe).

TMOUT Ha a PS1 prompt kiadása után aTMOUT-ban megadott számú percig nem adunk ki parancsot, a shell befejezi futását. Akkor célszerû használni, ha el szoktuk felejteni a kijelentkezést. 0 értéke esetén nem lép ki a shell.

VISUAL Ha ennek értéke emacs,gmacs, vagy vi-ra végzõdik, akkor a megfelelõ parancsszerkesztési mód lép mûködésbe.


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:/u/local:/usr/local/bin:/usr/bin/X11:.
PS1='$LOGNAME'@hostname' $ '
VISUAL=vi
FCEDIT=vi
export TERM=vt100
export VISUAL FCEDIT
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, VISUAL, FCEDIT é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.


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 /u/local/info/*/* \
                              | sed "s//u/local/info/\(.*\)\.news/\1/"`
    do
    if [[ $ans = exit ]]
    then
        exit
    fi
    more /u/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. Esetünkben --- tekintve, hogy a {select parancs nincs a Bourne-shellben --- ez a Korn-shell. A második sorban beállítjuk a select parancs által használt PS3 prompt értékét. A hirdetõtábla a /u/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ün 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árak -name Állomány -exec Parancs

a KiindulásiKönyvtárakbó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:
--------------------------------------------
export DATUM=linux1.teljes.`date "+%y%m%d"`
ssh -1 backup@nagylinux "mkdir $DATUM"
cd /home/projects
touch teljes_mentes
for dir in `ls -1 `
do
   tar -zcvf - $dir | ssh -1 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 -1 backup@nagylinux "cd $DATUM; split --bytes=690m  - $dir.tgz."
done

--------------------------------------------
heti:
--------------------------------------------
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 -1 backup@nagylinux "cat >$MENTES"
mv uj_heti_mentes regi_heti_mentes


--------------------------------------------
napi:
--------------------------------------------
cd /home
touch uj_napi_mentes
export MENTES='Napi/linux1.d'.`date "+%y%m%d"`.tgz
echo $MENTES
find . -newer regi_napi_mentes -type f -print >/tmp/uj_napi_menteslista
tar -zcvf - -T /tmp/uj_napi_menteslista | ssh -1 backup@nagylinux "cat >$MENTES"
mv uj_napi_mentes regi_napi_mentes

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

Állományok feldolgozása


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éreszû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.

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élszeru
szem elõtt tartani: a sorok maximálisan 2048 karakter hosszúak
lehetnek, a hosszabb sorokat a grep betördeli. A paragrafusok (l.
-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 Kiterjesztett reguláris kifejezésként értelmezi mindegyik mintát Ha a kapcsoló egy adott rendszerben nem létezik, akkor a grep helyett az egrep parancsot használva ugyanezt a funkciót megkapjuk.. A semmi minta (NULL) minden sorral egyezik.

-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újsor karakter 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.

-h Hatására több állomány esetén sem írja ki az állományneveket.

-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.

-p[Elválasztókarakter] A mintát tartalmazó teljes paragrafust kiírja. A paragrafusokat egymástól az üres sorok választják el. Amennyiben megadjuk az Elválasztókaraktert, a grep annak megfelelõen értelmezi a paragrafust.

-q Nem ír ki semmit a kimenetre, pusztán nulla visszatérési értéket ad, ha a megadott minta létezik.

-s Nem írja ki a nem létezõ, vagy nem olvasható állományokra vonatkozo hibaüzeneteket.

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

-w Egész szavakat keres.

-x Azokat a sorokat írja ki, melyeknél a megadott minta a teljes sorral egyezik.



Példák:

A proba állományban keressük meg azokat a sorokat, melyek betûvel
kezdõdnek:
grep '^[a-zA-Z]' proba Enter

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.

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 Enter

vagy
grep 'abc Enter
> xyz' proba Enter
vagy
grep -E 'abc|xyz' proba Enter

Ez utóbbi esetben kiterjesztett reguláris kifejezést használtunk, melyben a | jel grep VAGY mûveletet jelent.


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 (l. 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õlreguláris kifejezések (l. vi) a sed megenged néhány eltérést.


A pont minden karaktert helyettesít, még a nem sorvégi újsor karaktert is, eltérõen az ed (vi) szerkesztõtõl.

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 megegyezo sorszámú soron végzi el a parancsot.

A sed a megadott parancsokat vagy a standard bementrõl veszi (elso 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ületminta 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ületettá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ányparancsállomány vé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:

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

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.*\([0-9]*\)/(\1)/" lpr

Ez az utasítás a Page szót tartalmazó, és 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).

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 szerint.

A rendezés mezõk és oszlopokmezõ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 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.

-c Lellenõrzi, hogy a megadott állomány a megadott szabályok szerint sorba van-e rendezve. Ha igen, nulla értékkel tér vissza.

-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övetkezo 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õMezo 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õ utolso 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 (l. -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

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.


A következõ parancs lexikografikus sorrendbe teszi az állományt úgy, hogy nem tesz különbséget kis- és nagybetû között (l. -f kapcsoló), és az ismétlõdõ sorokat csak egyszer írja ki (l. -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.

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


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).



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

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