Funktionen

1)
Eine Funktion ist ein Stück zusammengehörenden Codes, der es erlaubt, eine bestimmte Aufgabe in wiederverwendbarer Art umzusetzen. Eine Funktion enthält normalerweise thematisch zusammengehörigen Code. Es können beliebig viele Parameter an eine Funktion übergeben, und beliebig viele Funktionswerte von ihr zurückgegeben werden.

Funktionen werden normalerweise verwendet, um den Code übersichtlicher zu gestalten und/oder um Aktionen, die aus sehr vielen Code Zeilen bestehen, unter einem Namen zusammenzufassen.

Eine Funktion wird mit Hilfe des Schlüsselwortes function eingeleitet und mit dem zugehörigen end abgeschlossen.

Hier ein einfaches Beispiel:

function SagHallo()
	print( "Hallo" )
end

Hier sehen wir auch den 5. Anweisungstyp: Die Funktionsdefinition.

Funktionen werden nach dem folgenden Aufbauschema definiert:

function functionname([param1[, param2[, ...]]])
end

Die Funktion heisst SagHallo und benötigt keinerlei Parameter.
Sie ruft eine weitere Funktion (print) auf um „Hallo“ auszugeben.
Es werden keinerlei Werte zurückgegeben.
Der Aufruf im Code erfolgt also einfach mit „SagHallo()“.
Der in einer Funktion enthaltene Code wird erst dann ausgeführt, wenn die Funktion aufgerufen wurde. Egal an welcher Stelle die Funktion im Code steht.

Ein leicht erweitertes Beispiel:

function AntwortBitte()
 	print( "Antwort kommt gleich..." )
	return 42
end

Diese Funktion gibt, wenn sie aufgerufen wird, den Text „Antwort kommt gleich…“ aus, und liefert die Zahl 42 zurück. Ruft man diese Funktion so auf: „AntwortBitte()“ dann verfällt der Rückgabewert, da er nicht weiter verwendet wird. Benötigt man den Wert, kann man ihn sich in einer Variable merken: „antwort = AntwortBitte()“. Somit wird „antwort“ nach dem Aufruf die Zahl 42 enthalten.

Das Schlüsselwort return kann von einer Reihe von Rückgabewerten gefolgt werden.
return ist immer die letzte Anweisung in einem Block.

Nun ein Beispiel mit Parametern:

function Addiere( _zahl1, _zahl2 )
    return _zahl1 + _zahl2
end

Parameter werden zwischen der öffnenden und der schließenden Klammer hinzugefügt und von Kommata getrennt.

Die Funktion erwartet nun zwei Parameter, _zahl1 und _zahl2. Die Summe dieser Parameter wird zurückgegeben. Der Unterstrich vor dem Variablennamen ist nicht notwendig. Er kann jedoch verwendet werden um Funktionsparameter von anderen Variablen abzugrenzen.
Die Zeile print( Addiere( 17, 4 ) ) ruft zunächst „Addiere“ mit 17 und 4 auf. Die Funktion gibt 21 zurück. Dieses Ergebnis wird direkt an print weitergegeben und somit auf dem Bildschirm ausgegeben.

Der letzte Parameter in einer Parameterliste kann auch '…' sein, eine variable Argumentliste, die alle Parameter enthält, die nicht in die zuvor hinzugefügten Parameter passen. Näheres dazu noch im Verlaufe des Tutorials.

Funktionen sollten immer nacheinander deklariert werden:

function Nummer1( _nenParameter )
	MachWas( _nenParameter )
end
 
function Nummer2()
 	return "zzzZZ"
end

Es gibt keine Fehlermeldung, wenn man Funktionen ineinander deklariert. Dies sollte man allerdings nicht machen, da der Code dann höchstwahrscheinlich nicht mehr das macht was man möchte:

function Nummer1( _nenParameter )
 	MachWas( _nenParameter )
	function Nummer2()
		return "zzzZZ"
	end
end

Weiterhin muss jeder Funktionsname einzigartig sein. Hat man zwei Funktionen mit gleichem Namen, wird die neuere (weiter unten im Code stehende) die ältere überschreiben. Dies ist genau wie bei Variablen:

meinWert = 17;
meinWert = 4;

Nun enthält „meinWert“ 4, da einem identischen Namen ein anderer Wert zugewiesen wurde.

Funktionen werden genauso behandelt wie jeder Wert auch: Sie können erstellt werden, Variablen zugewiesen und untereinander verglichen werden usw.
Deswegen werden sie auch als „first-class values“ bezeichnet.

Deswegen können Funktionen, genauso wie jeder Wert, einer Variablen zugewiesen werden.

SagHallo = function() print( "Hallo" ) end

Der Variable „SagHallo“ wird eine Funktion zugewiesen die „Hallo“ ausgibt. Die Funktionalität ist exakt identisch mit der im ersten Beispiel. Es wurde nur eine andere Schreibweise gewählt um die Zuweisung zu verdeutlichen. Da es eine Variable ist, kann man damit auch alles machen, was man normalerweise mit Variablen macht.

AuchHallo = SagHallo
AuchHallo();

Hier wird der Variable „AuchHallo“ zunächst der Wert (die Funktion!) von „SagHallo“ zugewiesen. „SagHallo“ wird nicht ausgeführt (es stehen keine Klammern für einen Aufruf dahinter).
Anschliessend wird „AuchHallo“ ausgeführt, da es die gleiche Funktion wie „SagHallo“ enthält wird also anschliessend „Hallo“ auf dem Schirm ausgegeben.

Lokale Funktionen können auch definiert werden:

local function functionname([param1[, param2[, ...]]])
end

Diese Schreibweise entspricht:

local functionname
functionname = function([param1[, param2[, ...]]]) end

Das bedeutet, dass die folgenden beiden Anweisungen nicht äquivalent sind:

-- Variante 1
local fac = function(_n)
	if _n == 1 or _n == 0 then
		return 1 
	else 
		return fac(_n - 1) * _n -- Die globale Funktion fac() wird aufgerufen - das ist möglicherweise ein Fehler/nicht gewollt
	end
end
 
-- Variante 2
local function fac(_n)
	if _n == 1 or _n == 0 then
		return 1
	else
		return fac(_n - 1) * _n -- Hier wird die lokale Funktion fac() aufgerufen - so, wie es gewollt ist, um die Fakultät zu berechnen
	end
end

Weiterführende Links

Zurück
Weiter
Zur Übersicht

1) Dieses Tutorial ist teilweise aus dem S5-Wiki übernommen und wird noch überarbeitet