A Shell Scripts függvényeinek megértése és írása – VI. rész

A függvények fontos szerepet játszanak minden programozási nyelvben. Sok valódi programozási nyelvhez hasonlóan a bash is rendelkezik olyan funkciókkal, amelyeket korlátozott megvalósítással használnak.

Mik azok a függvények?

A programozásban a függvények a program egy adott feladatot végrehajtó szakaszai. Ebben az értelemben a függvény egyfajta eljárás vagy rutin. Amikor egy függvényt hívunk, a program elhagyja az aktuális kódrészt, és elkezdi végrehajtani a függvényen belüli első sort. Ha ismétlődő kód van, vagy egy feladat ismétlődik, fontolja meg egy függvény használatát.

Vegyük például azt az esetet, amikor meg kell találnunk egy szám faktoriálisát egy adott program több szakaszában. Ahelyett, hogy minden alkalommal megírnánk a teljes kódot (a faktoriális kiszámításához), megírhatjuk a kódnak azt a részét, amely egy blokkon belül egyszer kiszámítja a faktoriálist, és többször is felhasználhatja.

Miért írunk függvényeket?

1. Segít a kód újrafelhasználásában.
2. A program olvashatóságának javítása.
3. Változók hatékony felhasználása a programon belül.
4. Lehetővé teszi a program részenkénti tesztelését.
5. A programot egy csomó allépésként jeleníti meg.

Funkciók shell szkriptekben

A függvények shell szkriptben történő írásának általános szintaxisa a következő módokat tartalmazza.

function func_name {
	. . .
	commands
	. . .
}

or

func_name ( ) {
	. . .
	commands
	. . .
}

Opening curly braces can also be used in the second line as well.

func_name ( )
{
	. . .
	commands
	. . .
}

Mindig szabadon írhat érvényes parancsokat ezekbe a funkcióblokkba, ahogy azt általában a shell szkriptekben tesszük. Most próbáljunk meg írni egy egyszerű szkriptet egy kis funkcióval.

#!/bin/bash

call_echo ( ) {
	echo ‘This is inside function’
}

op=$1

if [ $# -ne 1 ]; then
	echo "Usage: $0 <1/0>"
else
	if [ $1 = 0 ] ; then
		echo ‘This is outside function’
	elif [ $1 = 1 ] ; then
		call_echo
	else
		echo ‘Invalid argument’
	fi
fi

exit 0

A függvénydefiníciónak meg kell előznie az első hívást. Semmi sem olyan, mint a függvény „deklarálása” hívás előtt. És mindig beágyazhatunk függvényeket a függvényekbe.

Megjegyzés: Az üres függvények írása mindig szintaktikai hibákat okoz.

Ha ugyanazt a függvényt többször definiáljuk, akkor a végső verziót hívjuk meg. Vegyünk egy példát.

#!/bin/bash

func_same ( ) {
	echo ‘First definition’
}

func_same ( ) {
	echo ‘Second definition’
}

func_same

exit 0

Paramétereket felvevő és értékeket visszaadó függvények

Menjünk mélyebbre, ha figyelembe vesszük a paramétereket felvevő és az értékeket visszaadó függvényeket. Ahhoz, hogy egy függvényből értéket adjunk vissza, a beépített „return” parancsértelmezőt használjuk. A szintaxis a következő.

func_name ( ) {
	. . .
	commands
	. . .
	return $ret_val
}

Hasonlóképpen adhatunk át argumentumokat a szóközökkel elválasztott függvényeknek az alábbiak szerint.

func_name $arg_1 $arg_2 $arg_3

A függvényen belül elérhetjük az argumentumokat $1, $2, $3 és így tovább. Tekintse meg a következő példaszkriptet, hogy megkeresse a maximum két egész számot a függvény használatával az egyértelműség növelése érdekében.

#!/bin/bash

USG_ERR=7

max_two ( ) {
	if [ "$1" -eq "$2" ] ; then
		echo 'Equal'
		exit 0
	elif [ "$1" -gt "$2" ] ; then
		echo $1
	else
		echo $2
	fi
}

err_str ( ) {
	echo "Usage: $0 <number1>  <number2>"
	exit $USG_ERR
}

NUM_1=$1
NUM_2=$2
x
if [ $# -ne 2 ] ; then
	err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
	if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  
		max_two $NUM_1 $NUM_2
	else
		err_str
	fi
else
	err_str
fi

exit 0

A fenti kissé bonyolultnak tűnik, de egyszerű, ha végigolvassuk a sorokat. Először beágyazott if-else if sorok érvényesítési célból, azaz az argumentumok számának és típusának ellenőrzéséhez reguláris kifejezések segítségével. Ezután két parancssori argumentummal meghívjuk a függvényt, és ott megjeleníti az eredményt. Ennek az az oka, hogy egy függvényből nem tudunk nagy egész számokat visszaadni. A probléma megkerülésének másik módja a globális változók használata az eredmény függvényen belüli tárolására. Az alábbi szkript elmagyarázza ezt a módszert.

#!/bin/bash

USG_ERR=7
ret_val=

max_two ( ) {
	if [ "$1" -eq "$2" ] ; then
		echo 'Equal'
		exit 0
	elif [ "$1" -gt "$2" ] ; then
		ret_val=$1
	else
		ret_val=$2
	fi
}

err_str ( ) {
	echo "Usage: $0 <number1>  <number2>"
	exit $USG_ERR
}

NUM_1=$1
NUM_2=$2

if [ $# -ne 2 ] ; then
	err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
	if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  
		max_two $NUM_1 $NUM_2
		echo $ret_val
	else
		err_str
	fi
else
	err_str
fi

exit 0

Most próbáljon ki néhány izgalmas problémát, amelyeket az előző shell script-sorozatban magyaráztunk el a következő függvények használatával.

1. Alapvető Linux Shell Scripting nyelvi tippek – I. rész
2. 5 Shell Script Linux kezdőknek a Shell programozás elsajátításához – II. rész
3. Áthajózás a Linux BASH Scripting világán – III. rész
4. A Linux Shell programozás matematikai vonatkozása – IV. rész
5. Matematikai kifejezések kiszámítása Shell Scripting nyelven – V. rész

A következő részben visszatérek a funkcionális funkciókhoz, például a helyi változók használatához, a rekurzióhoz stb. Legyen naprakész a megjegyzésekkel.