Lua Functions

In Lua ist die Funktion die Hauptmethode zur Abstraktion von Anweisungen und Ausdrücken. Sie kann sowohl zum Verarbeiten spezieller Aufgaben als auch zur Berechnung von Werten verwendet werden.

Lua bietet viele eingebauten Funktionen, die Sie leicht in Ihrem Programm aufrufen können, wie z.B. die Funktion print() kann die übergebenen Parameter auf der Konsole ausgeben.

Lua Funktion gibt es zwei Hauptanwendungen:

• 1.Die angegebene Aufgabe erledigen, in diesem Fall wird die Funktion als Anrufstatement verwendet;

• 2.Werte berechnen und zurückgeben, in diesem Fall wird die Funktion als Ausdruck in einem Zuweisungsstatement verwendet.

Funktion Definition

Lua Programmiersprache Funktion Definition Format ist wie folgt:

optional_function_scope　function　function_name(　argument1,　argument2,　argument3...,　argumentn)
　　　　function_body
　　　　return　result_params_comma_separated
end

Analyse:

• optional_function_scope: Dieser Parameter ist optional und bestimmt, ob die Funktion eine globale oder lokale Funktion ist, wenn dieser Parameter nicht gesetzt ist, ist die Funktion standardmäßig global. Wenn Sie die Funktion als lokale Funktion festlegen möchten, müssen Sie den Schlüsselwort local.

• function_name: Funktion Name spezifizieren.

• argument1, argument2, argument3..., argumentn: Funktion parameter, mehrere Parameter werden durch Komma getrennt, die Funktion kann auch ohne Parameter verwendet werden.

• function_body: Funktionsskript, der Codeblock, der im Funktionskörper ausgeführt werden muss.

• result_params_comma_separated: Funktion Rückgabewert, Lua-Funktionen können mehrere Werte zurückgeben, wobei jeder Wert durch Komma getrennt ist.

Online-Beispiel

Die folgenden Beispiele definieren die Funktion max()，Parameter ist num1, num2，verwendet zur Vergleich der Größe von zwei Werten und zur Rückgabe des größeren Werts：

Example

--[[　Funktion gibt den größeren Wert von zwei Werten zurück　--]]
function　max(num1,　num2fwrite("%d%d\n",
　　　if　(num1　>　num2)　then
　　　　　　result = num1;
　　　else
　　　　　　result = num2;
　　　end
　　　return　result;　
end
--　Funktion aufrufen
print("Der größere Wert der beiden Werte ist ",max(10,4))
print("Der größere Wert der beiden Werte ist ",max(5,6))

))}}

Der größere Wert der beiden Werte ist　　　　　10
Der größere Wert der beiden Werte ist　　　　　6

In Lua können wir Funktionen als Parameter an Funktionen übergeben, wie im folgenden Beispiel gezeigt:

Example

myprint　=　function(param)
　　　print("Das ist ein Druckfunktionen　-　　　##",param,"##)
end
function add(num1,num2,functionPrint)
　　　result = num1　+　num2
　　　--　Aufruf des übergebenen Funktionsparameters
　　　functionPrint(result)
end
myprint(10fwrite("%d%d\n",
--　myprint als Parameter übergeben
add(2,5,myprint)

))}}

Dies ist die Druckfunktion　-　　　##　　　　10　　　　##
Dies ist die Druckfunktion　-　　　##　　　　7　　　　##

Mehrere Rückgabewerte

Lua-Funktionen können mehrere Rückgabewerte liefern, z.B. string.find, das die Start- und Endindizes des Treffers "beginnend mit" und "endend mit" zurückgibt (wenn kein Treffer vorhanden ist, wird nil zurückgegeben).

> s, e = string.find("de.oldtoolbag.com", "w3codebox　
> print(s, e)
5　　　　10

In Lua-Funktionen kann eine Liste der zu returning Werte nach dem return-Kommando aufgeführt werden, um mehrere Werte zurückzugeben, z.B.:

Example

function maximum(a)
　　　　local mi =　1　　　　　　　　　　　　　--　Maximalwertindex
　　　　local m = a[mi]　　　　　　　　　　--　Maximalwert
　　　　for i, val in ipairs(a) do
　　　　　　　if val > m then
　　　　　　　　　　　mi = i
　　　　　　　　　　　m = val
　　　　　　　end
　　　　end
　　　　return m, mi
end
print(maximum({8,10,23,12,5))

))}}

23　　　　3

Variablenparameter

Lua-Funktionen können eine variable Anzahl von Parametern akzeptieren, ähnlich wie in der C-Sprache, indem man in der Parameterliste drei Punkte ... verwendet, um anzugeben, dass die Funktion variable Parameter hat.

function add(...)　　
local s = 0　　
　　for i, v in ipairs{...} do　　　--> {...} stellt ein Array dar, das aus allen variablen Parametern besteht　　
　　　　s = s　+　v　　
　　end　　
　　return s　　
end　　
print(add(3,4,5,6,7))　　--->25

Wir können variable Parameter einer Variable zuweisen.

Beispiel, wir berechnen den Durchschnitt mehrerer Zahlen:

Example

function average(...)
　　　result = 0
　　　local arg={...}　　　　--> arg ist ein Array, eine lokale Variable
　　　for i, v in ipairs(arg) do
　　　　　　result = result　+　v
　　　end
　　　print("Gesamtzahl der übergebenen Werte", #arg .. " Elemente")
　　　return result/#arg
end
print("Durchschnittswert", average(10,5,3,4,5,6))

))}}

The execution result of the above code is:　6　Total number of inputs
number　　　　5Average value5

Wir können auch die Anzahl der variablen Parameter durch select("#",...) ermitteln:

Example

function average(...)
　　　result = 0
　　　local arg={...}
　　　for i, v in ipairs(arg) do
　　　　　　result = result　+　v
　　　end
　　　print("Gesamtzahl der übergebenen Werte", select("#",...) .. " Elemente")
　　　return result/select("#",...)
end
print("Durchschnittswert", average(10,5,3,4,5,6))

))}}

The execution result of the above code is:　6　Total number of inputs
number　　　　5Average value5

.

Example

Sometimes we may need several fixed parameters plus variable parameters, and the fixed parameters must be placed before the variable parameters:　　---function fwrite(fmt, ...)
　　　　>Fixed parameters fmt　　　　　
end
return io.write(string.format(fmt, ...))3fwrite("w　　　　　　　---codebox\n")3>fmt = "w　　
codebox, no variable arguments.　1,　2fwrite("%d%d\n",　　　---)　1　>fmt = "%d%d", variable arguments are　2

The output is:

w3and
12

codebox It is usually only necessary to use {…} when traversing variable arguments, but variable arguments may contain some nil, so you can use selectfunction to access variable arguments: select('#', …) or

• select(n, …)

• select('#', …) returns the length of the variable arguments. n select(n, …) is used to return the nth argument in the argument list.

When calling select, you must pass a fixed argument selector (selector switch) and a series of variable arguments. If the selector is a number n, then select returns the nth argument in the argument list. n number of arguments, otherwise it can only be a string #, so select returns the total number of variable arguments.

Example Code:

Example

do　　
　　　　function foo(...)　　
　　　　　　　　for i =　1, select('#', ...) do　　-->Get Total Number of Parameters
　　　　　　　　　　　　local arg = select(i, ...);　-->Read Parameters
　　　　　　　　　　　　print("arg", arg);　　
　　　　　　　　end　　
　　　　end　　
　　
　　　　foo(1,　2,　3,　4);　　
end

The output is:

arg　　　　1
arg　　　　2
arg　　　　3
arg　　　　4