szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:linux|< Linux]]

====== Shell programozás ======

  * **Szerző:** Sallai András
  * Copyright (c) 2011, Sallai András
  * Szerkesztve: 2011-2021
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu

===== Bevezetés =====


A shell programok végrehajtható parancsok gyűjteménye, vagyis egymás után
írt parancsok listája egy állományban. Nevezhetjük egyszerűen shell scriptnek is.

A shell scripteknek nem kötelező kiterjesztést megadni. Ha mégis szeretnénk
megadni akkor válasszuk az .sh kiterjesztést. A rendszer azonban nem a kiterjesztésből
fogja eldönteni, hogy shell script vagy nem az. 

Ha egy fájlba parancsokat írunk, azt shell scriptként futtatva a parancsok
végrehajtódnak. A unixos rendszerekben a scripteket egy karakterpárral kezdjük:
  #!
A rendszer ebből tudja, hogy valamilyen scriptről van szó.
Ha egy hexa szerkesztővel nézzük:
  hexedit scriptnev
Akkor azt mondhatjuk a következő kódú karakterrel kezdődik:  
  23 21
A unix alapú rendszerekben a futtatható fájloknak sincs kiterjesztése alapértelmezetten.
A Linux például ELF binárisokat futtat. Egy ELF bináris fájl eleje mindig a 
következő byte sorozattal kezdődik:
  7F 45 4C 46

Nézzük meg például az ls parancsunkat (Felhasználóként! Ne rendszergazdaként!).
  hexedit /bin/ls

Kilépés Ctrl + C

Ha a hexedit nem lenne telepítve: 
  apt install hexedit

A scriptek, tehát #! kezdődnek, de honnan tudja a rendszer, hogy milyen scriptről van szó?
A #! után adjuk meg az interpreter nevét és elérési útját. Perl script esetén például:
  #!/usr/bin/perl

Bash shell script esetén, például:
  #!/bin/bash

Python script esetén, például:
  #!/usr/bin/python


===== Első lépések =====

  * Szükségünk van egy szövegszerkesztőre, amiben megírjuk a scriptet.
  * Futtathatóvá kell tennünk a scriptet. 
    * Szintaktika:
      * chmod jogok script-neve
    * Példa:
      * chmod +x bar
      * chmod 755 bar
  * Futtatjuk a scriptet
    * Szintaktika:
      * bash script-neve
      * sh script-neve
      * ./script-neve
    * Példa:
      * $ bash bar
      * $ sh bar
      * $ ./bar

Megjegyzés

Az utolsó szintaktikában a ./ jelentése: az aktuális könyvtár, de csak ez.

A . (dot) karaktert használhatjuk önmagában is, ez induláskor nem hoz létre egy új shell másolatot. 

Szintaktika:
<code bash>
. script-neve
</code>

Példa:
<code bash>
$ . foo
</code>

Ha egy olyan scriptet indítunk amelyik nem áll le azonnal (például vár adatbevitelre), akkor meggyőződhetünk a fentiekről ha futtatjuk a felhasználó nevén a pstree parancsot. Legyen a példa kedvéért egy joska nevű felhasználó aki a ker.sh nevű scriptet indítja. A scriptet ./ker.sh vagy . ker.sh formában indítja, ekkor lekérdezzük a folyamatfát:
<code bash>
pstree joska
</code>


A lehetséges kimenet ./ker.sh esetén:
<code>
bash───pstree

bash───ker.sh
</code>


A lehetséges kimenet . ker.sh esetén:
<code>
bash───pstree

bash
</code>

A különbséget a ps parancs is megmutatja:
<code bash>
ps u
</code>
Kapcsolónak csak a "u" kapcsolót kell megadni. 


Azt már tudjuk, hogy egy shell sciptet mindig "#!" karakterekkel kezdjük és utána leírjuk az értelmező útvonalát. De hogyan deríthatő ki az értelmező útvonala? Mi most, Bash shell-t szeretnénk használni.
A which parancs megmondja, hogy honnan fut egy parancs:
<code bash>
which bash
</code>

===== Megjegyzés =====

<code bash script.sh>
#!/bin/bash

# egy soros megjegyzés

: '
Több
soros
megjegyzés
'
</code>

A (:) kettőspont után szóköz szükséges.
===== Kivitel =====


Hozzuk létre első "Helló Világ!" nevű shell scriptünket. készítsünk egy elso.sh nevű fájlt, melynek tartalma a következő:



<code bash elso.sh>
#!/bin/bash
echo "Helló Világ!"
</code>

Adjunk rá futtatási jogot:
<code bash>
chmod +x elso.sh
</code>

Futtassuk:
<code bash>
./elso.sh
</code>

Ezek után minden további scriptünket így kell létrehoznunk.


Sorvége:
<code bash>
echo -n "Helló Világ!"
</code>

Utóbbi utasítás a -n hatására nem ír a sorvégére sortörést.

===== Escape szekvenciák =====


Az "Escape" karakterek engedélyezése:
<code bash>
echo -e "Helló Világ!"
</code>

A -e kapcsoló engedélyezi az escape karakterek  értelmezését a karakterláncokban:
  * \a csengő
  * \b egy karakter törlése visszafelé
  * \c nem ír ki újsor karaktert
  * \f lapdobás
  * \n új sor
  * \r kocsi vissza
  * \t vízszintes tabulátor
  * \v függőleges tabulátor
  * <nowiki>\\</nowiki> backslash
  * \0nnn a karakter ASCII kódja nnn (oktálisan)
  * \xnnn a karakter ASCII kódja nnn (hexadecimálisan)

Az escape karakter a normál karakter egy speciális értelmezése. Az "a" például csengőhang, az "n" sortörés. Azt, hogy speciális escape értelmezés következik egy "\" visszaperjel karakterrel mondjuk meg. A következő parancs például a "Helló" és a "Világ!" szöveget külön sorba írja:

<code bash>
echo -e "Helló\nVilág!"
</code>


<note tip>
LXTerminalban: Szerkesztés > Beállítások > Stílus > Hallható csengőhang [✔]
</note>
===== Változók és az értékadás =====
A változók kis és nagybetű érzékenyek. A SZAM és a szam változó két különböző változó. 
Az átláthatóság érdekében a változóneveket nagybetűvel szokás írni. 

<code bash>
SZAM=3
SZOVEG="alma"
echo $SZAM
echo $SZOVEG
</code>

Az értékadó operátor előtt és után nem hagyhatunk whitespace karaktert, mert akkor a SZAM vagy SZOVEG
változót egy parancsnak venné.


===== Változó deklaráció =====

<code bash>
#!/bin/bash

declare -i szam
szam=4
szam=szam+1
szam+=1
echo $szam

</code>

<code bash>
#!/bin/bash

declare -i szam=4
szam=szam+1
szam+=1
echo $szam
</code>



===== Formázott kimenet =====

A printf utasítással a kiírt változókat, értékeket több módon formázhatjuk. 
Elsőként lássunk egy szimpla változó kiíratást:

<code bash>
printf "%s\n" $HOME
</code>

<code bash>
printf "%s\n" alma
</code>


<code bash>
printf "%d\n" 35
</code>

Szélesség megadása:
<code bash>
printf "%10d\n" 35
</code>

Vezető nullák:
<code bash>
printf "%0d\n" 35
</code>


<code bash>
printf "%f\n" 35,12345
</code>

Tizedesjegyek megadása:
<code bash>
printf "%.2f\n" 35,12345
</code>

Egyszerre több:
<code bash>
printf "%010.2f\n" 35,12345
</code>

A prrintf segítségével színezhetjük is a kimenetet:

  printf "\033[0;32mszínes szöveg\n"

  printf "\033[1;33mszínes szöveg\n"

Meg kell jegyezzem, az echo parancs a <nowiki>-e</nowiki> kapcsolóval
értelmezi az escape szekvenciákat, és ugyanez a hatás elérhető:

  echo -e "\033[1;33mszínes szöveg\n"

Unicode karakter kiíratása is lehetséges a \U escape szekvenciával. Lássuk az "üres" szót:
  printf "%b" "Unicode Character (U+7a7a) \U7a7a \n"
A "U" nagy u helyett használhatunk "u" kis u-t is.

Leghosszabb kiírható számjegy: 1234567890123456789

^  Formátumkód  ^  Leírás  ^
| d | Egész szám kiíratás |
| f | Valós szám kiíratás  |
| s | String kiíratás  |

^  Jelző  ^  Leírás  ^
|  0  | vezető nullák  |
|  -  | balra igazítás |
|  +  | előjel  |
===== Véletlen generálás =====
==== Véletlen szám ====
Az alábbiakban többféle véletlen szám előállítási lehetőséget ismerhetünk meg.

<code bash>
echo $RANDOM
</code>


<code bash>
n=$RANDOM
echo $n
</code>

1 és 3 között egy szám:
<code bash>
 echo $((RANDOM % 3 + 1))
</code>




0 és 4 közötti számot véletlenszerűen:
<code bash>
r=$RANDOM
R=$((r %= 5))

echo $R
</code>


0 és 4 közötti szám:
<code bash>
echo $(( $(od -An -N2 -i /dev/random) % 5))
</code>

Véletlenszám az od paranccsal:
<code bash>
od -A n -N 1 -t d < /dev/urandom
</code>

A -t d decimális formában kiírásról gondoskodik. A -N 1, egyetlen bájt vételét
írja elő. 

<code bash>
shuf -i 1-10 -n 1
</code>

Ha telepítve van a perl nyelv:
  perl -e 'print int rand 10, "\n"; '

==== Véletlen bemenet ====

A shuf a bemenetére kapott sorokból véletlenszerűen választ,
majd kiírja a kimenetre:

  echo -e "1\n2\n3\n4\n5" | shuf -n 1

könyvtár tartalmából véletlenszerűen választás:
  ls dir1 | shuf -n 1





===== Kifejezés kiértékelése =====

<code bash>
expr 1 + 3
</code>
Az 1+3 összegét, azaz 4-et ad vissza



<code bash script.sh>
#!/bin/bash

A=3
B=7
expr $A + $B
</code>


<code bash script.sh>
#!/bin/bash

A=3
B=7
C=`expr $A + $B`
echo $C
</code>


<code bash script.sh>
#!/bin/bash

A=3
B=7
C=`expr $A "*" $B`
echo $C
</code>



<code bash script.sh>
#!/bin/bash

A=3
B=7
C=`expr \( $A "*" $B \) / 2 `
echo $C
</code>



<code bash script.sh>
#!/bin/bash

A=3
B=7
C=`echo  \( $A "*" $B \) / 2 | bc`
echo $C
</code>


Gyökvonás:
<code bash script.sh>
#!/bin/bash

echo sqrt\(9\) | bc
</code>



Hatványozás:
<code bash script.sh>
#!/bin/bash

echo 2 ^ 8 | bc
</code>

==== Dupla zárójel ====

A következő program a szam változó értéket 1-gyel növeli:
<code bash szamol.sh>
#!/bin/bash

szam=3
szam=$((szam+1))

echo $szam
</code>


Variációkat láthatunk a növelésre:
<code>
szam=$((szam+1))
((szam=szam+1))
((szam+=1))
((szam++))
</code>

==== A let kulcsszó használata ====

<code bash>
#!/bin/bash

szam=3
let "szam=szam+1"
echo $szam
</code>

Variációk a let kulcsszó használatára:
<code bash>
let "szam=szam+1"
let "szam+=1"
let "szam++"
let szam=szam+1
let szam+=1
let szam++
</code>

==== A bc ====

<code bash>
#!/bin/bash

declare -i szam=4
bc <<< "$szam+2"

</code>

<code bash>
#!/bin/bash

declare -i szam=4
echo "$szam+2" | bc

</code>

===== Bevitel =====

Ebben a részben megnézzük, hogyan kérhetünk be a billentyűzetről értékeket. 
<code bash>
echo -n "Szó: "
read SZOVEG
</code>

Egy szöveg bekérése a SZOVEG változóba. A bekérést a read utasítás végzi. Az előtte lévő echo utasítás jelzi a "Szó: " képernyőre való írásával, hogy egy szó begépelését várjuk. Az echo -n kapcsolója a "Szó: " szöveg után nem ír sortörést. Így a bekérés rögtön a kettőspont-szóköz után lehetséges. 


Bekérés echo nélkül:
<code bash script.sh>
#!/bin/bash

read -p "Felhasználónév: " USER

echo "A felhasználónév: "$USER
</code>

A bekérés szövegét echo nélkül is kitudjuk íratni a read -p kapcsolója segítségével. 





Beolvasás tömbbe:
<code bash script.sh>
#!/bin/bash

echo -n "Gyümülcsök: "

read -a GYUMOLCSOK

echo ${GYUMOLCSOK[0]}
echo ${GYUMOLCSOK[1]}

</code>

A read utasítás a -a kapcsoló hatására indexelt tömbváltozót hoz létre. Lásd "help read".

A beolvasandó értékeket szóközzel tagolva adjuk meg. Például:
<code>
Gyümölcsök: körte alma barack szilva
</code>



Jelszó beolvasása:
<code bash script.sh>
#!/bin/bash

echo -n "Jelszó: "
read -s JELSZO

echo
echo "A beírt jelszó: " $JELSZO

</code>


<code bash script.sh>
#!/bin/bash

read -p "Jelszó: " -s JELSZO

echo
echo "A beírt jelszó: " $JELSZO

</code>


Alapértelmezett szöveg megadása:
<code bash script.sh>
#!/bin/bash

read -e -i "joska" -p "Felhasználónév: " USER

echo "A beírt felhasználónév: "$USER

</code>
A "-e" kapcsoló is szükséges.





===== Szelekció =====
==== if ====


<code bash>
#!/bin/bash
SZAM=2
if [ $SZAM -eq 2 ]
then
    echo "Egyenlo"
else
    echo "Negy egyenlo"
fi
</code>

Az -eq egyenlőséget vizsgál. Használható még a "=" vagy a "==" karakterek is, viszont ezen operátorok előtt és után kötelező egy
vagy több whitespace karakter.


<code bash>
#!/bin/bash
SZAM=2
if [ $SZAM -ne 2 ]
then
    echo "Nem egyenlő kettővel"
else
    echo "Egyenlő kettővel"
fi
</code>

A -ne azt jelenti nem egyenlő. Használható helyette a != alak is.



<code bash>
#!/bin/bash
SZAM=2
if [ $SZAM -gt 2 ]
then
    echo "Nagyobb"
else
    echo "Kisebb vagy egyenlő mint kettő"
fi
</code>




<code bash>
#!/bin/bash
SZAM=2
if [ $SZAM -lt 2 ]
then
    echo "Kisebb mint kettő"
else
    echo "Nagyobb vagy egyenlő mint kettő"
fi
</code>





<code bash>
#!/bin/bash
SZAM=2
if [ $SZAM -le 2 ]
then
    echo "Kisebb vagy egyenlő mint kettő"
else
    echo "Nagyobb mint kettő"
fi
</code>



<code bash>
#!/bin/bash
SZAM=2
if [ $SZAM -ge 2 ]
then
    echo "Nagyobb vagy egyenlő"
else
    echo "Kisebb"
fi
</code>





==== elif ====

<code bash>
#!/bin/bash

read -p "Gyümölcs: " fruit

if [ "$fruit" = "alma" ]; then
	echo "Ez alma"	
elif [ "$fruit" = "körte" ]; then
    echo "Ez körte"
else
	echo "Nem alma és nem körte"	
fi

</code>


==== select ====


<code bash valaszt.sh>
#!/bin/bash

select i in "egy" "kettő" "három"
do
    echo Ezt választottad:
    echo $i
done
</code>

Kiírja az "egy", "kettő", "három" szavakat sorszámokkal bevezetve. Valójában egy ciklus is elindul. 
Mindig várja, hogy válasszunk egyet. A ciklus a Ctrl + C billentyűkombinációval is. 

A ciklus persze megszakítható a break utasítással a cikluson belülről is.

<code bash valaszt.sh>
#!/bin/bash

select i in "egy" "kettő" "három" "kilépés"
do
    echo Ezt választottad:
    echo $i
    if [[ "$i" = "kilépés" ]] ; then
	break
    fi
done
</code>

==== És, vagy logikai operátorok ====

Több feltétel is megadható, ha megduplázzuk a szögletes
zárójeleket:


<code bash>
if [[ $num -eq 3 && "$str" == foo ]]
then

  # Utasítások
fi
</code>




Vagy:
<code bash script.sh>
#!/bin/bash

A=0
B=1

if [[ $A -eq 1 || $B -eq 1 ]]
then
    echo "Ok"
else
    echo "Nem ok"
fi
</code>

És:
<code bash script.sh>
#!/bin/bash

A=0
B=1

if [[ $A -eq 1 && $B -eq 1 ]]
then
    echo "Ok"
else
    echo "Nem ok"
fi
</code>

Kevert:
<code bash script.sh>
#!/bin/bash

A=1
B=0
C=1

if [[ ($A -eq 1 || $B -eq 1) && $C -eq 1 ]]
then
    echo "Ok"
else
    echo "Nem ok"
fi
</code>


===== Szelekció másként =====

==== Szimpla szelekció ====

<code bash>
#!/bin/bash

A=1

[ $A -eq 1 ] && echo "Ok" || echo "Nem ok"
</code>

==== Vagy logikai operátor ====

<code bash>
#!/bin/bash

A=1
B=1

[ $A -eq 1 ] && [ $B -eq 1 ] && echo "Ok" || echo "Nem ok"
</code>

==== És logikai operátor ====

<code bash>
#!/bin/bash

A=1
B=1

[ $A -eq 1 ] && [ $B -eq 1 ] && echo "Ok" || echo "Nem ok"
</code>

==== Vegyes logikai operátorok ====

<code bash>
#!/bin/bash

A=1
B=1
C=0

([ $A -eq 1 ] || [ $B -eq 1 ]) && [ $C -eq 1 ] && echo "Ok" || echo "Nem ok"
</code>



==== Több ágú elágazás ====



<code bash>
echo "[O]lvas"
echo "[H]ozzáfűz"
echo "[S]zerkeszt"

read menupont

case "$menupont" in
  "O" | "o" )
      echo "Olvasási műveletek"
      ;;
  "H" | "h" )
      echo "Hozzáfűzési műveletek"
      ;;
  "S" | "s" )
      echo "Szerkesztési műveletek"
      ;;
esac
</code>


===== Iteráció =====


==== for ====


Számok 1-től - 10-ig, variációk:

<code bash>
for i in `seq 1 10`
do
    echo $i
done
</code>


<code bash>
for i in `seq 1 10`; do  echo $i ; done
</code>






<code bash>
for i in 1 2 3 4 5 6 7 8 9 10
do
    echo $i
done
</code>

Egy könyvtár tartalmát végig vesszük:

<code bash>
for i in `ls /etc`
do
    echo $i
done
</code>

A példában listázzuk az /etc könyvtár tartalmát.


Zip fájlok feldolgozása:
<code bash>
#!/bin/bash

for file in *
do
    if [[ "$file" = *.zip* ]]
    then
	echo "$file"
    fi
done
</code>


<code bash>
#!/bin/bash

for (( i=0; i<10; i++ ))
do
	echo "Helló"
done
</code>

<code bash>
#!/bin/bash

for (( i=0; i<10; i++ ))
do
	echo $i
done

</code>

==== while ====


Amíg típusú ciklus (while)


<code bash>
#!/bin/bash

SZAMLALO=1

while [ $SZAMLALO -lt 11 ]
do
        echo $SZAMLALO
        let SZAMLALO=SZAMLALO+1
done
</code>



Számok bekérése nulla végjelig:

<code bash>
#!/bin/bash

SZAM=1

while [ $SZAM -ne 0 ]
do
	echo -n "Szám: "
	read SZAM
done
</code>


 
Számok bekérése nulla végjelig, közben összegzés.

<code bash>
#!/bin/bash

SZAM=1
SZUM=0

while [ $SZAM -ne 0 ]
do
	echo -n "Szám: "
	read SZAM
	let SZUM=$SZUM+$SZAM
done

echo "Összeg: " $SZUM
</code>

A let nélkül sztringkét adja össze.

Végtelen ciklus létrehozása:
<code bash>
while true
do
   #amit csinálunk a végtelen ciklusban
done
</code>

Másik módszer a végtelen ciklusra:
<code bash>
while :
do
   #amit csinálunk a végtelen ciklusban
done
</code>


<code bash>
while :
do
   echo -n "Számot: "
   read SZAM
   if [ $SZAM -lt 1 ]
   then
      exit 0
   fi
done
</code>

==== Fájl olvasása ====

<code bash script.sh>
#!/bin/bash

while read sor
do
    echo $sor
done < gy.txt

</code>



<code bash script.sh>
#!/bin/bash

cat gy.txt | while read sor
do
    echo $sor
done

</code>

==== Könyvtár tartalmának olvasása ====

A .txt kiterjesztésű fájlok olvasása:
<code bash script.sh>
#!/bin/bash

DIR=konyvtar/alkonyvtar

cd $DIR

find $DIR -name '*.txt' | while read sor
do
    echo $sor
done

</code>


==== until ====

<code bash>
#!/bin/bash

SZAMLALO=1

until [ $SZAMLALO -gt 10 ]
do
        echo $SZAMLALO
        let SZAMLALO=SZAMLALO+1
done
</code>

===== Tömbök =====
Üres tömb:
<code bash>
tomb=()
</code>

Kezdőértéket zárójelek között adhatunk:
<code bash>
tomb=( "egy" "kettő" "három")
</code>

A Bash tömb tartalmazhat számokat és karakterláncokat is:

<code bash>
tomb=( 12 "egy" 45 29 "kettő" "három")
</code>




Hivatkozás egy tömbelemre: 
<code bash>
echo ${tomb[1]}
</code>
Ez a második elemet adja vissza, vagyis az indexelés 0-val kezdődik. 

A tömb elemei így is felvehetők:

<code bash>
tomb[0]=egy
tomb[1]=kettő
tomb[2]=három

echo ${tomb[1]}
</code>

==== A tömb tulajdonságai ====

<code bash>
#!/bin/bash

#Összes elem:
echo ${tomb[*]}
echo ${tomb[@]}

#Összes index:
echo ${!tomb[*]}
echo ${!tomb[@]}


# Elemek száma:
echo ${#tomb[*]}
echo ${#tomb[@]}

echo ${#tomb[0]}   # a 0-dik elem hossza


</code>



==== A tömb bejárása ====

<code bash>
#!/bin/bash

ketogenEtelek=(
        "Halsaláta"
        "Zöldségkör"
        "Húsleves"
        "Narancs-joghurt"
)

for item in ${ketogenEtelek[*]}
do
   echo $item
done
</code>


A tömb bejárása a for in szerkezettel, csak akkor működik, ha nincs 
szóköz a tömb elemeiben. Ha a tömb elemei szóközöket is tartalmaznak,
akkor a következő ciklus alkalmas bejárásra:

A "*" karakter helyett használhatunk "@" karaktert is.

Szimpla for ciklus használata:
<code bash>
#!/bin/bash

etelek=(
        "Halsaláta (uborka, tonhal, tejföl)"
        "Zöldségkör (tejföl, túró, zöldségek)"
        "Húsleves"
        "Narancs joghurt"
)

n=${#etelek[@]}

for (( i=0; i<n; i++))
do
    echo ${ketogenEtelek[$i]}
done
</code>

==== Tömb műveletek  ====
Hozzáfűzés
<code bash>
dobasok=(1 5 4)
dobasok+=(7 8)
echo ${dobasok[@]}
</code>


Ürítés:
  dobasok=()


Tömb része:
<code bash>
echo ${tomb[@]:2:3}
</code>

A 2-s indextől szeretnénk, 3 darab karaktert.


Elem törlése:
<code bash>
tomb=(33 49 56 27)
unset tomb[1]
echo ${tomb[@]}
</code>

Ha ezek után kiíratjuk a tömb indexeit, ezt kapjuk:
<code bash>
echo ${!tomb[@]}
0 2 3 
</code>
Hiányzik a 1-s index.

Egész tömb törlése:
<code bash>
unset tomb
</code>

==== Deklarált tömb ====

Indexelt tömb:
<code bash>
declare -a szamok
</code>

Asszociatív tömb:
<code bash>
declare -A tomb
</code>


Indexelt tömb feltöltéssel:

<code bash>
declare -a szamok
szamok+=35
szamok+=47
</code>




Asszociatív tömbnek értékadás:

<code bash>
declare -A dolgozo

#egy érék hozzáadása:
dolgozo[fizetes]=3800000

#több érték hozzáadása:
dolgozo=([nev]=János [telepules]=Szolnok)
echo ${dolgozo[nev]}
</code>


===== String =====
==== Hossz ====

<code bash>
SZOVEG="Nagy János"
meret=${#SZOVEG}
echo $meret
</code>

<code bash>
SZOVEG="abc123"
HOSSZ=$(printf "%s" "$SZOVEG" | wc -c)
</code>

<code bash>
echo ${#SZOVEG}
echo -n $SZOVEG | wc -m
echo -n $SZOVEG | wc -c
printf $SZOVEG | wc -m
expr length $SZOVEG
expr $SZOVEG : '.*'
</code>

==== Kisbetű, nagybetű  ====

<code>
STR="Alma"

echo $STR  # alma

echo ${STR,,}  # alma


echo ${STR^^}  # ALMA
</code>

A fenti megoldás, csak a 4.x Bash verziótól működik. 

Használhatjuk a tr parancsot, ami viszont nem viszi a magyar ékezetes karaktereket.
<code>
STR="Alma"
echo "$STR" | tr '[:upper:]' '[:lower:]'
</code>

Megoldás lehet még az awk használata:

<code bash>
echo "ÁRVÍZTŰRŐ" | awk '{print tolower($0)}'
</code>


<code bash>
echo "Árvíztűrő" | awk '{print toupper($0)}'
</code>


A Bash megoldás esetén használhatunk egyetlen ^ vagy , karaktert. Ekkor csak az első
karakterre vonatkozik a beállítás.

<code>
STR=árvíztűrő; echo ${STR^}
Árvíztűrő
</code>

Milyen betűk legyenek nagybetűk:
<code bash>
STR=árvíztűrő; echo ${STR^^[v,z]}
árVíZtűrő
</code>

==== Ékezetlenítés ====

Repülő ékezetek, normál ékezet helyett:
<code bash>
echo árvíztűrő | iconv -f UTF-8 -t ASCII//TRANSLIT
</code>


<code bash>
# apt install unaccent
</code>


<code>
$ echo árvíztűrő | unaccent utf-8
arvizturo
</code>


<code>
$ echo árvíztűrő | sed 'y/áíéóöőúüű/aieooouuu/'
</code>

==== Tartalmaz-e? ====

<code bash>
#!/bin/bash

if [[ $a == *"é"* ]]
then
	echo "Van benne é betű"
else
	echo "Nincs benne é betű"
fi

</code>

==== String bejárása karakterenként ====

<code bash>
#!/bin/bash

a=béla
for (( i=0; i<${#a}; i++ ))
do
	echo "${a:$i:1}"
done
</code>

==== Regex ====

Az [a-z] mint megfelel az angol ábécé betűinek plusz
áíóöúü betűknek, de nem felel meg a ő és ű betűknek. 

<code bash>
#!/bin/bash

a=belí

if [[ $a =~ ^[a-z]+$ ]]
then
	echo "Megfelel"
else
	echo "Nem felel meg"
fi
</code>

==== String darabolása ====

<code bash darabol.sh>
#!/bin/bash

str="alma:körte:barack:szilva"

IFS=':' read -ra tomb <<< "$str"

echo ${tomb[0]}

</code>

==== Heredoc szintaxis ====

<code bash naplo.sh>
#!/bin/bash

date=$(date "+%Y-%m-%d")

cat << EOT

==========

$date

Óra:
Téma:
Hiányzók:
	1 óra:
	2 óra:
	3 óra:
Dolgozat:
Hetes:

EOT

</code>

==== Üres sorok törlése ====
<code>
cat fajl.txt | sed '/^$/d'
</code>

==== Adott karakterek törlése ====

A következő karakterek törlése:

| . ? - , |

<code>
cat fajl.txt | sed '/[\.?-\,]//g'
</code>

===== Visszatérési érték =====


Vizsgáljunk meg egy program végrehajtásának sikerességét. A példában az smbmount parancsot vizsgáljuk a
végrehajtás sikerességéről.

<code bash>
#!/bin/bash
  
smbmount //server/megosztasnev -o username=joe,password=titok,uid=joe,gid=csoport
  
if [ $? == 0 ]
then
    echo
    echo "A végrehajtás sikeres"
    echo
else
    echo
    echo "Hiba a végrehajtás során"
    echo
fi
</code>  
  


===== Karaktersorozat vizsgálatok =====

Operátorok:
|  =  | egyenlő  |
|  !=  |  nem egyenlő  |
|  <  |  rövidebb  |
|  >  |  hosszabb  |
|  -z $NEV  |  a NEV üres  |



<code bash>
#!/bin/bash

ELSO="Kati"
MASODIK="Kati"

if [ $ELSO = $MASODIK ]
then
    echo Egyezik
else
    echo Nem egyezik
fi
</code>


Üres vagy nem üres a string:
<code bash>
#!/bin/bash

ELSO=""

if [ -z $ELSO ]
then
    echo Üres
else
    echo Nem üres
fi
</code>


Az ASCII táblában előrébb vagy hátrább van-e:
<code bash>
#!/bin/bash

ELSO="szilva"
MASODIK="zalma"

if [ $ELSO \> $MASODIK ]
then
    echo "Hátrébb van"
else
    echo "Előrébb van"
fi
</code>

vagy így:

<code bash>
#!/bin/bash

ELSO="szilva"
MASODIK="zalma"

if [[ $ELSO > $MASODIK ]]
then
    echo "Hátrébb van"
else
    echo "Előrébb van"
fi
</code>


<code bash>
#!/bin/bash

ELSO="s*"

# minta egyezés
if [[ $ELSO == s* ]]
then
    echo "s-el kezdődik"
else
    echo "Nem s-el kezdődik"
fi

</code>



<code bash>
#!/bin/bash

ELSO="s*"

# literális egyezés
if [[ $ELSO == "s*" ]]
then
    echo "s* van benne"
else
    echo "Nem s* van benne"
fi
</code>


<code bash>
#!/bin/bash

ELSO="s*"

# literális egyezés
if [ "$ELSO" == "s*" ]
then
    echo "s* van benne"
else
    echo "Nem s* van benne"
fi
</code>




===== Függvények, eljárás használata =====


Függvény:
<code bash minta.sh>
function kiir() {
    echo "Helló Világ"
}

kiir
</code>



Függvény paraméterrel:
<code bash minta.sh>
function kiir() {
    echo $1
}

kiir "Ezt írd ki"
</code>


Bemenő paraméter és visszatérési érték:
<code bash fg.sh>
#! /bin/bash

function dupla() {
		local res=$(echo "$1 * 2" | bc)
		echo "$res"	
}

result=$(dupla 3)
echo $result

</code>


Ez a megoldás is működik, de az előbbi korrektebb:
<code bash vissza.sh>
#! /bin/bash

function dupla() {
		res=$(echo "$1 * 2" | bc)	
}

dupla 3
echo $res

</code>



Példa:

<code bash>

#!/bin/bash

# Rekurzívan az alkönyvtárakban is átnevez minden fájlt kisbetűsre
# Jelenleg csak fájlokra működik, könyvtárakra nem.
# Latin2-es környezetben működik (1 karakter == 1 byte), UTF-8-ban nem.
# UTF-8-as környezetben a tr helyett a sed parancsot használjuk!

function files()
{
    for i in * ; do
      if [ -f "$i" ]; then
        j=`echo "$i" | tr '[:upper:]' '[:lower:]'`
        if [ "$i" != "$j" ]; then
          mv -i "$i" "$j"
        fi
      fi
    done
}


function dirs()
{
    for i in *; do
	    if [ -d "$i" ]; then
	      cd "$i"
	      dirs
	      files
	      cd ..
	    fi
    done
}

dirs
files

</code>

==== Tömbök ====

Tömb visszatérési érték:

<code bash>
function leker_tomb() {
   tomb=(9 4 2 5)
   echo ${tomb[@]}
}

a_tomb=($(leker_tomb))
echo "Összes elem: "${tomb[@]}
echo "Mérete: "${#tomb[@]}
</code>



===== Változók hatásköre =====
A következő script szemlélteti a változók hatáskörét. A local kulcsóval létrehozott függvényen belüli változó nem látszik csak a függvényben. Az $ERO nevű változó viszont globális, mindenhol látszik. 



<code bash>
#!/bin/bash

ERO="85"
function csokkent {
    local MERTEK=5
    echo "Erő csökkentése..."
    ERO=`expr $ERO - $MERTEK`
}
echo "Erő: $ERO"
csokkent
echo "Erő csökkentés után: $ERO"
echo "Csökkentés mértéke: $MERTEK"
</code>




Külső változó felhasználása:
<code bash>
#!/bin/bash

szam=45

function csinal() {
  szam=100
  echo "Működik"
}

csinal
echo "$e"
</code>

===== Fájl és könyvtár tesztek =====

==== Használható kapcsolók listája ====


  * -b filename  A fájl speciális blokk?
  * -c filename  A fájl speciális karakterfájl?
  * -d directoryname A könyvtár létezik?
  * -e filename A fájl létezik?
  * -f filename A fájl általános fájl, nem egy könyvtár?
  * -G filename Ha a fájl létezik, érvényes tulajdonos érvényes csoportazonosító?
  * -g filename true ha fájl létezik és van set-group-id
  * -k filename Sticky bit
  * -L filename Szimbolikus link
  * -O filename True ha fájl létezik és az felhasználó érvényes azonosító.
  * -r filename Ellenőrzés, ha a fájl olvasható.
  * -S filename Ellenőrzés, ha a fájl socket
  * -s filename Ellenőrzés, ha a fájl nem nonzero méretű
  * -u filename Ellenőrzés, ha set-ser-id bit be van állítva
  * -w filename A fájl írhatóságának ellenőrzés
  * -x filename A fájl futtathatóságának olvasása

==== A fájl létezésének ellenőrzése ====


<code bash>
#!/bin/bash
file="adat.txt"
if [ -e $file ]; then
	echo "A fájl létezik"
else 
	echo "A fájl nem létezik"
fi 
</code>




==== Első paraméter létezésének vizsgálata ====


<code bash>
#!/bin/bash        
if [ -z "$1" ]; then 
    echo usage: $0 directory
    exit
fi
</code>

==== Könyvtár vizsgálat ====

Példa a könyvtárvizsgálatra:

<code bash>
if [ -d "$DIRECTORY" ]; then
    # Mit tegyünk, ha a $DIRECTORY könyvtár létezik
fi
</code>
A könyvtár neve (esetleg útvonala) a $DIRECTORY változóban találjuk.


Ha a könyvtár nem létezik:

<code bash>
if [ ! -d "$DIRECTORY" ]; then
    # Mit tegyünk, ha a $DIRECTORY nem létezik
fi
</code>


==== Parancs kimenete ====


<code bash>
[ -z "`ls`" ] && echo "Nincs fájl"
</code>

A [ -z az ls által visszaadott sztring hosszát vizsgálja, hogy az 0 értékű-e.

<code bash>
[ -n "`ls`" ] && echo "Van valamilyen fájl"
</code>

A [ -n az ls által visszaadott sztring hosszát vizsgálja, hogy az nagyobb-e mint 0.









===== Tesztek a test paranccsal =====

Az if utasítást után a test parancs is használható feltételek 
meghatározására. A következőkben erre látunk példát. 

  test <KIFEJEZÉS>

  [ <KIFEJEZÉS> ]

A két utasítás visszatérhet 0-val (TRUE) vagy 1 (FALSE) értékekkel.

<code bash>
#!/bin/bash

if test -e /etc/group
then
  echo "A csoportfájl létezik..." >&2
else
  echo "Valami nem kerek!" >&2
  exit 1
fi
</code>


A test utasítás után a kifejezés egy -e kapcsolóval kezdődik. 
Azt mondja egy fájl létezését akarjuk tesztelni. Ez után következik,
hogy melyik fájlt szeretnénk tesztelni.


A fenti utasításnak teljesen megfelel a "[" karakter. Ha megnézzük az
/usr/bin könyvtárat, akkor találni fogunk ott egy ilyen futtatható 
programot. 

<code bash>
#!/bin/bash

if [ -e /etc/group ]
then
  echo "A csoportfájl létezik..." >&2
else
  echo "Valami nem kerek!" >&2
  exit 1
fi
</code>
===== Beépített változók =====

| $0       | A script neve  |
| $1 | paramét1  |
| $2 | paramét2  |
| $3 | paramét3  |
| $4 | paramét4  |
| $5 | paramét5  |
| $6 | paramét6  |
| $7 | paramét7  |
| $8 | paramét8  |
| $9 | paramét9  |
| $#       | argumentumok száma  |
| $@       | az összes argumentum |
| $?       | az utolsó folyamat kilépési kódja  |
| $LINENO  | a script aktuális sora  |
| $HOSTNAME  | hol fut a script  |
| $USER      | a scriptet futtató felhasználó  |
| $SECONDS   | a futtatás kezdete óta eltelt idő  |
| $RANDOM    | minden hivatkozáskor más véletlen számot ad  |





===== Fájlok, könyvtárak neveinek kezelése =====

A következő példákban egy könyvtárban található fájlok
vagy alkönyvtárak tartalma helyett, azok nevein
hajtunk végre valamit. Jelenleg csak kiíratjuk a nevüket. 

<code bash olvas.sh>
#!/bin/bash

FAJLOK='*.txt'
ls $FAJLOK | while read next_file
do
	echo $next_file
done
</code>


<code bash olvas.sh>
#!/bin/bash

DIR=/home/utvonal

cd $DIR

for FILE in *
do
    echo Könyvtárnevek: $FILE
done
</code>


<code bash olvas.sh>
#!/bin/bash

DIR=/home/utvonal

cd $DIR

find $DIR -name '*.txt' | while read filename
do
    echo $filename
done
</code>

===== Fájlok tartalmának kezelése =====

A következő példa bemutatja hogyan tudjuk olvasni egy fájl tartalmát. 

<code bash>
while read sor
do
    echo $sor
done < gy.txt
</code>

Ebben a példában is egy fájl tartalmát olvassuk, kicsit másként.
<code bash>
cat gy.txt | while read sor
do
    echo $sor
done
</code>






===== Backup =====


Egyszerű archiválás:

<code bash>
#!/bin/bash
tar -czf joskadokuarchiv.tar.gz /home/joska/doku
</code>

Egy összetettebb archiváló:
<code bash>
#!/bin/bash

DATUM=$(date +%Y%m%d)
MENTENDO=/home/andras/bin
KIMENET=mentes-joskahome_$DATUM.tar.gz

tar -czf $KIMENET $MENTENDO
</code>


===== Paraméterek használata =====


<code bash>
#!/bin/bash

if [ "$#" == "0" ] 
then
    echo "Használat: ./parosit.sh Név1 Név2"
    exit
fi

echo "Ennyi nevet írtál: $#"

echo $1 és $2 jó választás együtt

echo "A paramétereid: $@"
</code>



===== Szignálok elkapása (trap) =====
A trap paranccsal szignálokat kaphatunk el. Ha valaki megnyomja például a
Ctrl + C, akkor a script befejezése előtt még tehetek valami a "csinald" nevű
függvényben. Persze tetszőleges függvény írható a helyére. 

<code bash>
#!/bin/bash

trap csinald INT

csinald()
{
    echo Valaki megnyomta a Ctrl + C! Nem kéne
}

sleep 5
</code>

===== Temp fájlok =====

  $ mktemp vmi.XXX
   vmi.YzM

A program kiírja milyen fájlt hoz létre. Az X-ek heléyre
véletlen karaktereket helyettesít a program.


Lehet hosszabb is:
  mktemp vmi.XXXXXXXX

A következő módon kinyerhető a fájl neve:
  TEMP=$(mktemp vmi.XXX)


Ezek után így használjuk:
<code>
TEMP=$(mktemp /tmp/temporary-file.XXXXXXXX)
echo valami > ${TEMP}
</code>

===== Naplózás =====

Ha szeretnénk, hogy a script a /var/log könyvtárba nalózzon,
akkor hozzunk ott létre a script számára egy könyvtárat:
  # mkdir /var/log/sajatScriptNev


Naplózás a /var/log/syslog fájlba is történhet a logger nevű 
parancs segítségével:
  logger uzenet

Megadható a script neve is:
  logger –t ScriptNev “Helló Világ”



===== Függelék =====

==== Futtatható fájlok ====

A futtatható fájlok miről ismerjük fel, itt vannak megadva:
<code bash>
/proc/sys/fs/binfmt_misc
</code>



==== Telepítés ====


<code bash>
apt-get -y install mc >/dev/null 2>&1
</code>


<code bash>
aptitude -y install mc >/dev/null 2>&1
</code>


==== Aktuális könyvtár ====

Parancssorból az aktuális könyvtárnév, útvonal nélkül:
  basename $PWD


Másik lehetőség:
  echo ${PWD##*/}


Esetleg így:

<code bash>
ACTDIR=$(basname $(pwd))
echo $ACTDIR
</code>



===== Példák =====

==== Másolás időbélyeg alapján ====

Legrégebbi fájl másolása:
<code bash script.sh>
#!/bin/bash

cd /útvonal/könyvtár
cp `ls -t1 *.txt | tail -1` /másik/útvonal/könyvtár/

</code>

Legújabb fájl mozgatása:
<code bash script.sh>
#!/bin/bash

cd /útvonal/könyvtár
cp `ls -t1 *.txt | head -1` /másik/útvonal/könyvtár/

</code>


==== Feltöltés FTP-re ====

<code bash fel.sh>
cd /útvonal/könyvtár
wput ./ ftp://felhasználónév:jelszó@url/könyvtár/
</code>



<code bash fel2.sh>
#!/bin/sh

USERNAME=jozsi
PASSWORD=titok
HOST_NAME=localhost
LOG=naplo.txt
BATCH=id_batchfile

echo "user $USERNAME $PASSWORD" > $BATCH
echo "bin" >> $BATCH
echo "send egy.txt" >> $BATCH
echo "send ketto.txt" >> $BATCH
echo "exit" >> $BATCH

ftp -n -v $HOST_NAME < $BATCH > $LOG

rm $BATCH

</code>


<code bash fel3.sh>
#!/bin/sh

USERNAME=jozsi
PASSWORD=titok
HOST_NAME=localhost
LOG=naplo.txt

ftp -n -v $HOST_NAME > $LOG <<EOF

quote user $USERNAME
quote pass $PASSWORD
bin
send egy.txt
send ketto.txt
exit

EOF
</code>


<code bash fel4.sh>
#!/bin/sh

USERNAME=jozsi
PASSWORD=titok
HOST_NAME=localhost
LOG=naplo.txt

ftp -n -i -v $HOST_NAME > $LOG <<EOF

user $USERNAME $PASSWORD
bin
send egy.txt
send ketto.txt
exit

EOF

</code>


Így bekéri a jelszót

<code bash fel5.sh>
#!/bin/sh

USERNAME=jozsi
HOST_NAME=localhost
LOG=naplo.txt

ftp -n -i -v $HOST_NAME > $LOG <<EOF

user $USERNAME 
password
bin
send egy.txt
send ketto.txt
exit

EOF

</code>


<code bash fel6.sh>
#!/bin/sh

USERNAME=jozsi
PASSWORD=titok
HOST_NAME=localhost
LOG=naplo.txt

ftp -n -i -v  > $LOG <<EOF
open $HOST_NAME
user $USERNAME $PASSWORD
bin
send egy.txt
send ketto.txt
exit

EOF
</code>



Kicsit más:

<code bash fel7.sh>
#!/bin/sh

USERNAME=jozsi
PASSWORD=titok
HOST_NAME=localhost
LOG=naplo.txt

ftp -n -v $HOST_NAME  <<EOF >> $LOG 2>&1
quote user $USERNAME
quote pass $PASSWORD
bin
prompt off
mput *.txt
exit
EOF
</code>

==== Dátum ====

=== Dátum darabolása ===


<code bash datum.sh>
#!/bin/bash

read Y m d H M <<<$(date "+%Y %m %d %H %M")

echo Az év: $Y
echo A hónap: $m
echo A nap: $d
echo Az óra: $H
echo A perc: $M
</code>

==== Naplófájl figyelése ====

<code bash figyel.sh>
STR=elnok
tail -f /var/log/syslog |
while read -r sor
do
    [[ "$sor" != *$STR* ]] && continue
	echo "Volt bejegyzés"
done
exit
</code>
==== Visszaszámlálás ====
A script használja az espeak programot. 
Ha nincs telepítve:
  apt-get install espeak

Kimondva:
<code bash visszaSzamolKimondva.sh>
for i in {"öt", "négy", "három", "kettő", "egy", "zéró"};do espeak -vhu "$i" && sleep 0.5; done
</code>


Ugyanaz kiírva:
<code bash visszaSzamolKiirva.sh>
for i in {5..1};do echo -n "$i. " && sleep 1; done
</code>

==== Lejárt műszakik figyelése ====

Egy fájlban tároljuk melyik járműnek mikor jár le a
műszakija. Egy scripttel pedig időnként, például időzítve
ellenőrizzük, és hangosan kimondatjuk, ha körülbelül 2 hónap
van a műszaki lejártáig.


<code txt vehicles.txt>
Rendszám:Műszaki lejár:Szükséges figyelmeztetés:Gyártmány:Egyéb
ABC-123:2018-08-22:igen:Lada:Nincs
ABD-123:2018-08-22:igen:Lada:Nincs
BBC-623:2016-04-22::Lada:Nincs
CAC-523:2018-02-22:igen:Lada:Nincs
ABK-423:2012-04-22:igen:Lada:Nincs
AKG-123:2016-05-22:igen:Lada:Nincs
GBC-123:2015-08-22:igen:Lada:Nincs
</code>


<code bash checkVehicle.sh>
#!/bin/bash

FILE=vehicles.txt

# DEBUG-hoz:
FIXDATE=2016-03-03

DATE=`date "+%Y-%m-%d"`

echo $DATE

HANYHONAPPAL_ELORE=2


function checkVehicle() {
    sor=$1
    LEJAR=`echo $sor | awk -F: '{print $2}'`

    LEJAR_EV=`echo $LEJAR | awk -F- '{print $1}'`
    AKTUA_EV=`echo $DATE | awk -F- '{print $1}'`
    if [[ "$LEJAR_EV" == "$AKTUA_EV" ]]
    then
	LEJAR_HO=`echo $LEJAR | awk -F- '{print $2}'`
	AKTUA_HO=`echo $DATE | awk -F- '{print $2}'`
	TEMP_HO=`expr $LEJAR_HO - $AKTUA_HO`
	if [[ $TEMP_HO -le $HANYHONAPPAL_ELORE ]]
	then
	    LEJAR_RENDSZAM=`echo $sor | awk -F: '{print $1}'`
	    espeak -vhu "Filgyelem! Lejáró műszaki."
            espeak -vhu "A $LEJAR_RENDSZAM rendszámú gépjármű műszakija ekkor lejár: $LEJAR"
	fi
    fi

}

cat $FILE | while read sor
do
    ERTESITES=`echo $sor | awk -F: '{print $3}'`
    if [[ "$ERTESITES" == "igen" ]]
    then
	checkVehicle $sor
    fi
done
</code>


==== A set parancs ====

Sikertelen parancs esetén kilépés:
<code bash>
#!/bin/bash

# Ha végrehajtás sikertelen a scriptben, akkor azonnal lépjen ki:
set -e

# Ha az aaaaa fájl nem létezik, akkor kilép. 
# Ha nincs set -e, akkor még kiírja a Valami szöveget is. 

ls aaaaa

echo Valami
</code>

Próbáljuk meg a scriptet végrehajtani set -e használata nélkül is. 

==== Zónafájl felvétele ====

A Debian GNU/Linux rendszeren a bind démon számára a zónákat a következő helyen kell beállítani:
  * /etc/bind/named.conf.local
Ezek után egy zónafájlt kell készíteni ebbe a könyvtárba:
  * /var/cache/bind/master

Ezt fogjuk automatizálni:

<code bash zoneAdd.sh>
#!/bin/bash
CONFIG=/etc/bind/named.conf.local
MZONES=/var/cache/bind/master

echo -n "Tartománynév: "
read DOMAIN

echo -n "IP cím: "
read IP


ZONEFILE=$DOMAIN.zone

cat << EOT >> $CONFIG
zone "$DOMAIN" in {
    type master;
    file "master/$ZONE";
};
EOT

cat << EOT >> $MZONES/$ZONEFILE
\$TTL 3D
@     SOA $DOMAIN. hostmaster.$DOMAIN. (
                      2017111701
                      8H
                      2H
                      4W
                      2H)
$DOMAIN.   NS   $DOMAIN.
$DOMAIN.   A    $IP
EOT
</code>

==== Kártyalapok kiíratása ====

<code bash lapok.sh>
#!/bin/bash

function lap() {
	x=$1
	y=$2

    f="\u2660"  # pikk
    tput cup $y $x
	echo -e "\u250c\u2500\u2500\u2510"
	tput cup $((y+1)) $x
	echo -e "\u25026$f\u2502"
	tput cup $((y+2)) $x
	echo -e "\u2514\u2500\u2500\u2518"
}

clear

lap 5 5
lap 10 5

</code>

Az eredmény:
<code>
     ┌──┐ ┌──┐
     │6♠│ │6♠│
     └──┘ └──┘
</code>

A vonalak:
<code>
                u2550   u252c
u250c ┌          ─      ┬           ┐  u2510

u2502 │           

u251c ├                 ┼ u253c     ┤ u2524

u2514 └                 ┴           ┘ u2518  
                        u2534
</code>



  * treff (♣) -- u2663
  * káró (♦) -- u2666
  * kőr (♥) -- u2665
  * pikk (♠) -- u2660

  * További unicode: https://unicode-table.com/hu/
===== Külső linkek =====
  * http://tldp.org/LDP/Bash-Beginners-Guide/html/ 2018)
  * http://tldp.org/LDP/abs/html/ (Advanced Bash-Scripting Guide; 2018)
  * http://tldp.org/HOWTO/Bash-Prog-Intro-HOWTO.html (2018)
  * http://www.freeos.com/guides/lsst/ch02sec01.html (2018)
  * http://www.freeos.com/guides/lsst/ (2018)
  * http://user.it.uu.se/~matkin/documents/shell/#simple_commands (2018)
  * http://www.arachnoid.com/linux/shell_programming.html (2018)
  * http://www.inf.u-szeged.hu/~kato/teaching/unix/unix3.html (2018)
  * http://www.arcania.hu/Informatika/linux/commands.html (2018)
  * http://www.linuxconfig.org/Bash_scripting_Tutorial (2018)
  * http://mywiki.wooledge.org/BashPitfalls (2018)
  * http://wiki.koczka.hu/index.php/Kezd%C5%91lap (Operációs rendszerek; 2018)
  * http://wiki.bash-hackers.org (2018)
  * http://wiki.bash-hackers.org/commands/classictest (2018)
  * http://www.comptechdoc.org/os/linux/programming/script/linux_pgscriptintro.html (2018)
  * http://www.linuxjournal.com/content/bash-arrays (2018)
  * http://www.linuxjournal.com/article/2807 (dialog parancs; 2018)
  * http://www.faqs.org/docs/Linux-HOWTO/Bash-Prog-Intro-HOWTO.html (2018)

  * http://hup.hu/node/111049 (Hasznos fórum téma; 2018) 
  * http://www.shelldorado.com/scripts/categories.html (2018)
  * http://www.linuxquestions.org/ (2018)
  * https://ryanstutorials.net/bash-scripting-tutorial/bash-variables.php (Változók; 2018)
  * https://www.linuxjournal.com/content/return-values-bash-functions (2020)
  * https://linuxhint.com/return-string-bash-functions/ (2020)
  * https://github.com/ruanyf/simple-bash-scripts (2020)