Unix - víceuživatelský (multiuser) a víceúlohový (multitask) OS

xterm - emulátor znakového terminálu pro X terminál
cmdtool - ... na Sunech

shell	- interpret příkazů (v DOSu COMMAND.COM)
	- běží ve znakovém terminálu (xterm)
	- začátek práce - přihlášení:
		login: xnovak00
		Password: /* zadáte heslo */
	- po přihláąení můľete zadávat příkazy shellu nebo spouątět programy
	- příkazový řádek:
		$ - standardní prompt
		příkaz odeąleme stiskem Return (Enter, CR)
		příkazy a názvy souborů jsou na rozdíl od DOSu case sensitivní
			(rozlišují se malá a velká písmena: echo, ECHO, Echo
			jsou tedy různé soubory (programy)
		příkazy a systémové programy jsou malými písmeny (ls, cp, copy)
		funkci příkazů a systémových programů modifikujeme pomocí
			parametrů (přepínačů, argumentů) (ls -l /)
			příkaz [-přepínače] [argumenty]
		příkazový řádek můľeme opravovat klávesou BackSpace (Ctrl-h)
		historie příkazů: zpět Ctrl-p, dopředu Ctrl-n
		editace příkazové řádky:
			úplné smazání:	Ctrl-u
			pohyb doleva:	Ctrl-b
			pohyb doprav:	Ctrl-f
			na konec:	Ctrl-e
			na začátek:	Ctrl-a
			mazání znaku:	Ctrl-d
	- nový xterm: myší nebo xterm &
	- ukončení shellu: příkaz exit nebo Ctrl-D
	- více verzí shellu: sh, ksh, bash, csh
	- manuálové stránky: chceme-li získat informace o některém příkazu,
		pouľijeme příkaz man. Např. man ls
			pohyb pouze dolů - Space
			předčasné ukončení - q
			vyhledávání příkazu podle klíčového slova -
						man -k concat
			vyhledání výskytu slova v (již otevřené) manuálové
			stránce - man ls
				  /file
			v manuálové stránce příkazu ls vyhledá výskyt slova
			file. Každý další výskyt - n.



Systém souborů v OS Unix
========================

stromová struktura (jako v DOSu)
/ - kořenový adresář (root)
  - oddělovač adresářů
(v DOSu \)
Př.: /home/vyuka/os1

jméno souborů - všechny znaky mimo /
speciální znaky shellu (např. @, \, $, ;, !, &, *, |, ?, %, #, ~, (, ), ...)
	se nedoporučují
relativní jméno souboru (seznam1.txt, ../seznam1.txt, seznamy/seznam1.txt)
absolutní jméno souboru (/dokument/seznamy/seznam1.txt)

Pracovní (aktuální) adresář - adresář, ve kterém se nacházíme (pwd)
Domovský adresář - každý uživatel má svůj domovský adresář. Po přihlášení
	do systému se nachází v domovském adresáři. Může si v něm budovat
	vlastní adresářovou strukturu.
	Např.: /homes/sts2/xn/xnovak00

Příkazy
-------

pwd - výpis jména pracovního adresáře
	(Shell je nakonfigurován tak, ľe ukazuje jméno pracovního adresáře
	v promptu.) 

cd - změna pracovního adresáře (v DOSu také cd)
	relativní jména adresářů (./ ../) 
	absolutní jména adresářů
	Př.:
	cd		bez parametrů - pracovním adresářem bude domovský
	cd ~		to samé - znak tilda ~ zastupuje vždy domovský adresář
	cd -		přechod do předchozího (ne nadřazeného!!!) adresáře
	cd texty	přechod do adresáře texty

ls - výpis obsahu adresáře (v DOSu dir)
	užitečné modifikace:
	ls -l		úplný výpis
	ls -a		vypíše i skryté soubory (.profile)
	Pozn. místo ls -l -a můžeme psát ls -la
	ls -F		označí adresáře (/) a spustitelné soubory (*)	
	ls -R		vypíše rekurzívně i obsahy podadresářů

mkdir - vytvoření adresáře (v DOSu mkdir, md)

rmdir - zrušení prázdného adresáře

rm - smazání souborů (v DOSu del, erase)
	užitečné modifikace:
	rm -rf texty	smaže adresář texty, který nemusí být prázdný
		(tj. smaže rekurzívně všechny podadresáře a soubory)
	!!! Vždy si dobře rozmyslete co maľete. V Unixu není žádná moľnost
	    obnovit smazané soubory (v DOSu undelete) !!!

cp - kopírování soubrů (v DOSu copy)
	cp zdroj cíl
	Pokud je jako cíl zadán adresář, vytvoří se v něm kopie zdrojového
	souboru. Jméno souboru zůstane zachováno. Pokud je jako cíl zadáno
	jméno již existujícího souboru, bude nenávratně přepsán.

mv - přemístění (přejmenování) souboru (v DOSu rename)
	Vše je stejné jako u cp, ale původní soubor se smaže (opět nenávratně).

ln - další jméno souboru (link) (v DOSu nic takového není)
	Jeden fyzický soubor na disku můľe mít více jmen.
	ln původní_jméno nové_jméno
	Při mazání souboru s více jmény (rm), zůstává soubor fyzicky na disku
	dokud existuje aspoň jedno jeho jméno.
   - symbolický link
	ln -s původní_jméno symbolický_link
	chová se jako "ukazatel na soubor" => Pokud smažeme soubor
	pod původním jménem, smaže se fyzicky z disku a symbolický
	link bude ukazovat do neznámého souboru.


Práce s myší
------------
1. přesun okna, změna velikosti
2. zmenšení okna na ikonu
3. vyvolání menu (pravé tlačítko ve volném prostoru)
4. cut & paste
	označení textu: a) stisknout levé tlačítko a táhnout
			b) jedno slovo - dvakrát na něj kliknout
			c) celý řádek - třikrát kliknout
	umístění textu - prostřední tlačítko
5. rolování okna xtermu - myą na pravý (tlustý) okraj okna a dále:
	stránka nahoru - pravé tlačítko
	stránka dolů - levé tlačítko
	spojitě - prostředním tlačíktem chytnout obdélníček a posouvat
	na libovolné místo - kliknout pravým tlačítkem někde na okraji

Atributy souboru
----------------
Atributy zjistíme příkazem ls -l

1. Přístupová práva (drwxrwxrwx)
	znak 1:	b = blokové zařízení (např. disk, viz. /dev)
		c = znakové zařízení (např. terminál, viz. /dev)
		d = adresář
		l = symbolický link
		- = obyčejný soubor
	1. trojice rwx - práva vlastníka
	2. trojice rwx - práva skupiny
	3. trojice rwx - práva vąech ostatních uľivatelů

		obyčejný soubor		adresář
	právo
	r - 	čtení			vypisování obsahu
	w - 	zápis (mazání)		vytváření a mazání souborů
	x -	spustit jako příkaz	procházení do podadresářů

2. Počet jmen (linků) obyčejného souboru.
   Počet podadresářů + 2 (./ ../) u adresáře.

3. Vlastník

4. Skupina do níľ vlastník patří

5. Velikost souboru
	adresáře: 96, 1024

6. Datum poslední modifikace

7. Jméno souboru

Příkazy
-------

chown - změna vlastníka
	chown nový_vlastník jméno_souboru

chmod - změna přístupových práv
	1. chmod [ugoa]{ + | - }[rwx] file . . .
	2. chmod 644 file	-rw-r--r--
	Př.: chmod a+rwx file = chmod 777 file
Shell	- interpret příkazů
	- programovací jazyk (if - then, for, case, proměnné)


Základní příkazy (pro demonstraci vlastností shellu)
----------------------------------------------------

cat - výpis obsahu souboru
	cat file1		výpis obsahu souboru file1
	cat file1 file2 file3	výpis obsahu souborů
cut - výběr určitých polí (sloupců) souboru
	cut -f2 file1		vypiš druhý sloupec
				implicitním oddělovačem je tab
	cut -f1,3 -d" " file1	vypiš první a třetí sloupec
				oddělovačem je mezera
head - zobrazení prvních několika řádků souboru
	head -n 2 file1		první dva řádky souboru file1
tail - zobrazení několika posledních řádků souboru
	tail -n 2 file1		poslední dva řádky souboru file1
	tail -n +2 file1	od druhého řádku do konce souboru
more - výpis po obrazovkách
	more file1
sort - setřídění souboru
	sort file1
grep - hledání řetězce v souboru
	grep xnovak00 seznam	vypíše řádky souboru seznam, které obsahují
				řetězec xnovak00
wc - (word count) počítá slabiky, slova nebo řádky souboru
	wc -l file1		spočítá řádky souboru file1
	wc file1		spočítá všechno

Všechny tyto příkazy mohou fungovat i jako filtry.


Vstup, výstup, přesměrování
---------------------------
Každý program otevírá aspoň 3 soubory: stdin (0), stdout (1) a stderr (2)
Přesměrování:
	stdin	<
		cat file1  =  cat , >>
		cat file2  =  file2 cat
	stderr 2>, 2>>
		rm neex_file 2>err
Přklady:
1)	cat file1 >file2 2>error
	Pokud file1 existuje, vypíše se do file2, pokud neexistuje, chybová
	hláška se zapíše do souboru error.
2)	cat file1 >file2 2>&1
	Standardní i chybový výstup do sterného souboru file2.

Here document - umoľňuje zapsat standardní vstup pro příkaz na příkazovou
řádku (vyuľívá se hlavně v dávkách)
Př.:	$ sort < tento
	> text
	> bude
	> seřazen
	> podle
	> abecedy
	> END

Vytvoření prázdného souboru:
    >file
    
Zahození výstupu:
    program > /dev/null
        

Roury (kolony, pipe)
--------------------
Příklad: Zjistíme, zda je přihlášen uživatel xnovak00.
1)	Bez použití roury (dočasný soubor).
	who >tmp
	grep xnovak00 tmp
	rm tmp
2)	Pomocí roury.
	who | grep xnovak00

tee - odbočka z kolony
	who | wc -l		kolik lidí je přihlášených
	who | cut -f1 -d" " | tee WHO | wc -l
				kolik lidí je přihlášených a navíc
				bude jejich seznam v souboru WHO

Proměnné
--------
Speciální (systémové) HOME, PATH, LOGNAME, PS1, ...

env - výpis speciálních proměnných

Definované uživatelem (měly by být malými psímeny).
Nemají typ, zachází s nimi podle potřeby.
a=123		Přiřazení hodnoty proměnné a (bez mezer).
b=$a		Přiřazení obsahu proměnné a do proměnné b (bez mezer).
echo $b		Zjiątění obsahu proměnné b.
Přiřazení výstupu programu do proměnné.
c=`pwd`		!!! zpětné apostrofy
echo $c

set		Výpis všech proměnných.
unset		Zruší proměnnou (nebude uľ definována)

Proměnné se samy od sebe nepředávají do subshellů, musí se použít příkaz export.
$ export DISPLAY

$proměnná, ${proměnná}	obsah proměnné
${#proměnná}		délka obsahu proměnné
${proměnná:-náhrada}	Pokud proměnná není definována, nebo obsahuje
			prázdný řetězec, tak se vypíše náhrada. Jinak
			se vypíše obsah proměnné.
${proměnná:=náhrada}	Pokud proměnná není definována, nebo obsahuje
			prázdný řetězec, tak se do ní přiřadí náhrada
			a vypíše se. Jinak se vypíše obsah proměnné.
${proměnná:+náhrada}	Pokud proměnná je definována, tak se vypíše
			náhrada. Jinak se neděje nic.
${proměnná#reg.výraz}
${proměnná##reg.výraz}	Pokud začátek obsahu proměnné odpovídá regulárnímu
			výrazu, tak se vypíše bez tohoto začátku, jinak se
			vypíąe celý obsah proměnné. # je pro nejmenší
			začátek odpvídající reg. výrazu, ## je pro největší.
${proměnná%reg.výraz}
${proměnná%%reg.výraz}	Jako #, ##, ale na konec.

typeset		- nastavuje vlastnosti proměnných
Př.:	$ typeset -l a		# proměnná bude převádět velká písmena na malá
	$ typeset +l a		# zruší předchozí vlastnost
	$ typeset		# vypíše vlastnosti všech proměnných
vlastnosti:
-L[n]	- omezení velikosti obsahu na n znaků zleva
-R[n]	- omezení velikosti obsahu na n znaků zprava
-Z[n]	- omezení velikosti obsahu na n znaků zprava, pokud je prvním znakem
	číslice, tak se zleva doplní nuly tak, aby celková délka obsahu byla n
-i	- s proměnnou se zachází jako s číslem, pokud se do ní přiřadí nějaký
	text, převede se na 0
-l	- převod na malá písmena
-r	proměnná bude read only (konstanta)
-u	- převod na velká písmena
-x	- proměnná se bude exportovat do subshellů

Procesy
-------
ps - výpis procesů
	$ ps -u xnovak00		vypiš vąechny procesy uľivatele xnovak00
kill - zaslání signálu procesu
	$ kill -s KILL 14397  =  $ kill -9 14397
				zabije proces 14397.
	$ man 5 signal		seznam signálů


Práce na pozadí
---------------
Přkazy, které trvají dlouho, nebo grafické aplikace spouątěné z příkazové
řádky spouštíme na pozadí. Shell pak bude opět schopen přijímat příkazy.
Výstupy programu spuštěného na pozadí je vhodné přesměrovat do souborů,
aby se nevypisovaly na terminál.

Znak & se aplikuje na celou rouru, protože roura se považuje za nový příkaz.


Příklad:
find / -name bin -print >vysl 2>/dev/null &
	Vyhledá všechny soubory (adresáře) bin v systému souborů.
	Výsledek hledání zapíše do souboru vysl a chybová hlášení se
	zahodí (/dev/null). Proces se spustí na pozadí (&), takže je
	shell schopen přijímat další příkazy. Na obrazovku se vypíše
	číslo jobu a PID posledního procesu v přpadné rouře.
	[1]     14071

Job na popředí se dá pozastavit Ctrl-Z.
jobs - výpis jobů
bg - přenese pozastavený job na pozadí
	bg %1
fg - přenese pozastavený job na popředí
	fg %1
kill - ukončí job
	kill %1


Spouštění více příkazů z jedné příkazové řádky
----------------------------------------------
; - odděluje příkazy stejně jako Enter
	$ date; ls; who
& - spustí vąechny příkazy paralelně na pozadí
	$ xterm & xterm & xterm &
&& - druhý přkaz se spustí, pokud první příkaz skončil úspěšně
|| - druhý přkaz se spustí, pokud první příkaz skončil neúspěšně
	$ gcc -o myprog myprog.c && myprog
	Pokud skončí překlad programu myprog.c úspěšně, je spuštěn.
	$ gcc -o myprog myprog.c || vi myprog.c
	Pokud skončí neúspěšně, spusť editor.
Přkazy se mohou sdružovat pomocí závorek.
Př.:	$ date; ls >file1
	$ (date; ls) >file1
Př.:	$ (sleep 5; date) & date


Progamování v shellu
--------------------

Dávky (scénáře, skripty)
------------------------
# Toto je poznámka ve skriptu. Znak "#" musí být na začátku řádku, nebo
bla bla bla # musí být oddělený od příkazů mezerou.

Spouątění dávky:
$ sh dávka # spustí se kopie shellu
$ . dávka # spouątí tento shell; vhodné pro nastavování proměnných
$ dávka # musí být nastaveno právo x

#! /bin/ksh		standardní začátek skriptu. Určujeme tím, který
			shell má dávku interpretovat v případě, že bude
			spuštěna jako příkaz (tj. nebude spuštěna jako
			parametr shellu).
Ladění scénářů:
$ sh -x dávka
$ sh -xv dávka


Zneplatnění zvláątního významu metaznaků
----------------------------------------
'...'	zneplatní vše
"..."	interpretuje $, `...`, \
\	zneplatňuje následující znak
Př.:	$ echo $HOME * \\a `pwd`
	$ echo "$HOME * \\a `pwd`"
	$ echo '$HOME * \\a `pwd`'

Argumenty skriptu
-----------------
Název programu: $0
Poziční parametry: $1, $2, $3, ..., $9
Všechny arumenty: $*
Počet argumentů: $#
shift - posuv argumentů (pouľijeme, pokud je argumentů víc než 9)
!!!!ZISKANI ARGUMENTU VE SKRIPTU POMOCI CYKLU: !!!!
for i; do
  echo $i
done	

Testování podmínek
------------------
Každý program produkuje při svém ukončení a návratu do shellu exit status.
$ echo $?		zjistí exit status posledního příkazu
Pokud je exit status 0, skončil program úspěšně, jinak došlo k nějaké chybě.
Podmínka v shellu je pravdivá, pokud je 0.

Příkaz test - dvě formy zápisu
1)	test -přepínač argument
2)	[ -přepínač argument ]
	kolem závorek musí být na obou stranách mezery
Příklady použití:
test $a, [ $a ]			je proměnná a definovaná?
test -f file1, [ -f file1 ]	existuje obyčejný soubor file1?
test -r file1, [ -r file1 ]	existuje soubor file1 a je čitelný?
podobně -w, -x
test -d file1, [ -d file1 ]	existuje soubor file1 a je to adresář?
test -s file1, [ -s file1 ]	existuje soubor file1 a je větší než 0 Byte?
test -h file1, [ -h file1 ]	existuje soubor file1 a je to symbolický link?
test -n str1, [ -n str1 ]	je délka řetězce str1 větší než 0?
test str1 = str2, [ str1 = str2 ]	jsou řetězce str1 a str2 stejné?
!= ... různé
test n1 -eq n2, [ n1 -eq n2 ]	jsou čísla n1 a n2 shodná?
další možnosti: -ne (různá), -gt (větší než), -ge (větší nebo rovno), ...
viz. man test
!!! Bacha na rozdíl mezi porovnáváním řetězců (=) a čísel (-eq).
Na podmínky se mohou aplikovat logické operátory AND (-a) a OR (-o).
Př.: [ -f file1 -a $prom = "ahoj" ]

Programové konstrukce
---------------------
if podmínka1		Př. $ if [ "" != `who | grep xnovak00` ]
then příkaz1		    > then echo xnovak00 je přihlášen
elif podmínka2		    > else echo xnovak00 není přihlášen
then příkaz2		    > fi
...
else příkazn
fi

Př. Test exit statusu programu (rm).
$ if rm file1 2>/dev/null
> then echo file1 byl smazán
> else echo soubor file1 neexistuje
> fi

while podmínka
do příkazy
done

until podmínka
do přkazy
done

case slovo in
vzor1) příkaz1;;
vzor2) příkaz2;;
...
esac

Ve vzorech lze použít regulární vyrazy (*, ?, [a-z], [1,2,3]).

for proměnná in seznam		$ for i in 1 2 3 4
do příkazy			> do echo $i
done				> done

Př.: Všem uživatelům systému zašli zprávu
# zbytečně složité - pouze pro ilustraci for
# stačilo by: mail `cat /etc/passwd | cut -d: -f1`  do
> mail $i  done

exit - předčasné ukončení scénáře
read - načtení hodnoty z klávesnice do proměnné

Jestliže se interpretuje výstup ze zpětných apostrofů (for i in `ls`),
povaľuje se znak konec řádku za oddělovač slov.

Příklad na for, if a case.
Maže soubory v aktuálním adresáři. Před každým smazáním se pro jistotu zeptá.
#! /bin/ksh
for i in *		# for i in `ls`		přes vąechny soubory
do
	if [ -f $i ]	# je-li to obyčejný soubor
	then
		echo Smazat $i?
		read tak_co
		case $tak_co in
			y|Y|a|A|yes|YES|ano|ANO) rm $i;;
			n|N|no|NO|ne|NE) echo nemažu $i;;
			q|Q|quit|QUIT) echo konec; exit;;
		esac
	fi
done

Pro předčasné opuštění těla cyklu lze pouľít příkazy break a continue.
(Stejně jako v C.)


od - výpis obsahu (binárnho souboru)
which - zjistí adresář, ve kterém se nachází spustitelný soubor
file - zjistí typ souboru
du - vypíąe velikost adresáře
df - zjistí volné místo na discích
cmp, diff - porovnávání souborů


sed, grep
=========
1) sed - proudový editor - spouštění:

a) sed 'seznam_příkazů' soubory
b) sed 'seznam_příkazů'		# čte stdin
c) sed -f cmd_file		# příkazy čte ze souboru cmd_file

Parametry sedu:

 -i nerozlišovat malá a velká písmena
 -w vybírat jen řádky, na nichž vzoru vyhovuje celé slovo
 -v negovat výsledek (vypisovat řádky, které nevyhovují vzoru)

Příkazy odpovídají příkazům editoru sed.

- bez uvedení rozsahu platí na každý řádek
- nelze použít relativní definice rozsahu (-3,+5) - jeden průchod
- vzory: ., x*, .*, [abc], [^abc], [a-z], [^a-z], ^, $
- rozsah lze zadat dvojicí vzorů:

$ ... | sed '/BEGIN/,/^$/s/text1/text2/g' | ...		# s - substituce
	nahradí všechny výskyty text1 za text2 na řádcích od prvního
	výskytu slova BEGIN do prvního následujícího prázdného řádku (^$)

- implicitní vlastností sedu je výpis řádku, takže

$ sed 10p soubor.txt
	výpíše celý soubor soubor.txt a 10. řádek tam bude dvakrát.

- tuto vlastnost lze potlačit přepínačem -n:

$ sed -n 10p soubor.txt
	vypíše jenom 10. řádek.

- negace rozsahu - příkaz se provede pouze na řádcích, které neodpovídají vzoru:

$ sed '10,20!s/ahoj/čau/g' soubor.txt
	...provede substituce na všech řádcích vyjma od 10. do 20.

Další příkazy:

q - ukončí sed:
$ sed 10q soubor.txt   ...vypíše prvních 10 řádků a pak skončí.

y - náhrady jednotlivých znaků
$ sed 'y/abcd/ABCD/' soubor.txt   ...nahradí písmena a,b,c,d odpovídajícími velkými písmeny.

d - vymaže všechny řádky mezi řádky vyhovující intervalu daném reg. výrazy
$ sed '/vzor1/,/vzor2/d' soubor.txt


2) tr - převod znaků
--------------------

- není vázaný tak jako sed na jednotlivé řádky, tj. nepředpokládá
  textový soubor. Mohou se nahrazovat (mazat) libovolné znaky.
- pracuje jako čístý filtr => neumí si otevřít soubor.
Př.:
$ tr [a-z] [A-Z] = 3 && NR <= 6 { print $0 }	# vytiskne třetí až šestý řádek

awk rozděluje text na záznamy a záznamy na pole. Implicitním záznamem je
jeden řádek, implicitním polem je slovo (posloupnost znaků mezi mezerami
a tabelátory). Celý záznam je uloľen v $0, jednotlivá pole v $1, $2, ...,
$10, ...

Nejčastějąí akcí je tisk:
{ print $0 }		# vytiskne celý záznam (řádek)
{ print $3 $1 }		# vytiskne třetí a první pole (slovo)
{ print $3, $1 }	# vytiskne třetí a první pole (slovo); navíc
			  k oddělování polí pouľije OFS (viz. dále)
{ print $3 "*" $1 }	# vytiskne třetí a první pole (slovo) oddělené *

Pokud funkce print nestačí, lze použít funkci printf známou z C.
{ printf("%s*%s\n", $3, $1) }	# viz. předchozí příklad

Zápis argumentů fukce printf je zde ale trochu volnější neľ v C, např.:
{ printf $3"*"$1"\n" }

Lze použít speciální znaky (i ve funkci print) 
\a - bell, \b - BS, \n - LF, \r - CR, \t - TAB, \nnn - znak zadaný oktalově.

Pokud se neuvede akce, vypisuje se implicitně celý záznam (řádek). Vzor
však musí být v tomto případě zadán.

Proměnné:
----------
1) vestavěné
např.:
	FS	- vstupní oddělovač polí (implicitně "[ \t]+")
		  FS=":"FS="\t+"
	OFS	- výstupní oddělovač polí (implicitně " ")
	RS	- vstupní oddělovač záznamů (implicitně "\n")
	ORS	- výstupní oddělovač záznamů (implicitně "\n")
	NF	- počet polí právě zpracovávaného záznamu
	NR	- číslo právě zpracovávaného záznamu
	FILENAME	- jméno zpracovávaného souboru
	OFMT	- výstupní formát čísel (implicitně "%.6g")

2) uživatelské
přiřazení: a=12.89, a=$1, a=length($2), a="ahoj"

Proměnné nemají typ, zachází se s nimi podle potřeby.

Numerické operace jsou jako v C:
přiřazení: =, +=, -=, /=, %=, *=, ^=
relace: ==, !=, <, >, <=, >=
aritmetické operace: +, -, *, /, %, ^(mocnina), ++, --

programové konstrukce - jako v C: if, ?:,  while, do, for, break, continue
!!!podmínky zase jako v C!!! (0 - false, !=0 - true)

pole: for (i=0; i<10; i++) a[i] = 2*i

Př.: tisk záznamů (řádků) v obráceném pořadí
	{ line[NR] = $0 }
END	{ for(i=NR; i>0; i--) print line[i] }

k indexování pole lze použít libovolný řetězec: name[karel] = "novák"
Př.:
Jan	200
Karel	100
Jan	300
...
chceme součet pro každé jméno:
	{ sum[$1] += $2 }
END	{ for (name in sum) print name, sum[name] }
(jiný for - přes všechny indexy pole)

exit - skočí na vzor END

Funkce:
-------

řetězcové:
----------
length(string)			# délka řetězce
substr(string, pos, len)	# vrátí podřetězec délky len od pozice pos
index(string, substr)		# vrátí pozici substr v řetězci string
match(string, reg_expr)		# hledá rag. výraz v řetězci a vrátí jeho pozici
split(string, a, fs)		# rozdělí řetězec string na jednotlivá pole,
				  která uloží do a[1], a[2], ... Oddělovačem
				  polí je regulární výraz fs
sub(for, repl, in)		# nahradí první výskyt retězce vyhovujícímu
				  regulárnímu výrazu for z řetězec repl
				  v retězci in
gsub(for, repl, in)		# ... všechny výskyty ...
aritmetické:
------------
sin, cos, exp, log, sqrt


PODMINKY: /test/
----------------
A) pro čísla

x -eq y <=> x=y
  -ne	    x<>y
  -gt	    x>y	
  -ge	    x>=y	
  -lt	    x