Gültigkeitsbereich

In der Skripterstellung ist ein Codeblock der Körper einer Kontrollstruktur oder Funktion. Der Gültigkeitsbereich (Scope) einer Variablen oder Funktion ist der Codeblock, der darauf zugreifen kann, und er kann global oder lokal sein. Alle Blöcke können auf globale Variablen und Funktionen zugreifen. Ein Block kann auf lokale Variablen und Funktionen im übergeordneten Block zugreifen, jedoch nicht auf die in seinen untergeordneten Blöcken.

Variablen und Funktionen haben standardmäßig globalen Gültigkeitsbereich, aber es ist fast immer besser, sie mit lokalem Gültigkeitsbereich zu deklarieren, da Luau schneller auf lokale Variablen und Funktionen zugreift als auf globale. Um einer Variablen oder Funktion lokalen Gültigkeitsbereich zu geben, setze das Schlüsselwort local vor ihren Namen, wenn du sie deklarierst.

Skripte können nicht auf globale und lokale Variablen oder Funktionen in anderen Skripten zugreifen. Wenn du Werte und Funktionen zwischen Skripten teilen möchtest, verwende ModuleScripts.

local helloWorld = 'Hallo Welt!'
local function printHelloWorld()
	print(helloWorld)
end
printHelloWorld() -- Hallo Welt!

• Block B kann auf die lokale Variable in Block A zugreifen.
• Block C kann auf die lokalen Variablen und Funktionen in den Blöcken A und B zugreifen.
• Block A kann nicht auf die lokalen Variablen und Funktionen in den Blöcken B oder C zugreifen.
• Block B kann nicht auf die lokale Variable in Block C zugreifen.

Globaler Gültigkeitsbereich

Nachdem du eine globale Variable oder Funktion deklariert hast, kann jeder Codeblock im selben Skript darauf zugreifen. Variablen und Funktionen haben globalen Gültigkeitsbereich, es sei denn, du deklarierst sie mit dem Schlüsselwort local.

Im folgenden Code hat testVar globalen Gültigkeitsbereich innerhalb der lokalen Funktion testFunc(). Wenn Luau testFunc() aufruft, wird testVar der Wert 64 zugewiesen. testVar hat globalen Gültigkeitsbereich, sodass die Funktion print() außerhalb von testFunc() darauf zugreifen und 64 ausgeben kann.

Beispiel für globale Funktionen und Variablen
local function testFunc()  -- lokaler Gültigkeitsbereich
	testVar = 64  -- globaler Gültigkeitsbereich
end

testFunc()

print(testVar) -- 64

Im folgenden Code beginnt die globale Variable x bei 0, wird bei jeder Iteration der for-Schleife um 1 erhöht und danach mit einem Endwert von 4 erneut ausgegeben.

x = 0  -- Globale Variable "x"

for i = 1, 4 do
	x += 1
	print("Globale 'x' = " .. x)
end

print("Globale 'x' = " .. x)

--[[ Ergebnisausgabe:
Globale 'x' = 1
Globale 'x' = 2
Globale 'x' = 3
Globale 'x' = 4
Globale 'x' = 4
]]

Es ist einfacher, globale Variablen und Funktionen zu deklarieren, da du nicht so viel tippen musst, aber globale Variablen und Funktionen haben im Vergleich zu lokalen die folgenden Nachteile:

• Luau greift auf globale Variablen und Funktionen mit einer Hash-Suche zu, daher ist ihre Nutzung in Bezug auf die Leistung kostspielig. Die Verwendung einer globalen Variable in einer zeitkritischen Schleife kann die Leistung um mehr als 10% verringern im Vergleich zur Verwendung einer lokalen Variable in derselben Schleife.
• Luau gibt lokale Variablen nach dem Ende ihres Gültigkeitsbereichs frei, was den Speicherverbrauch reduziert.
• Du kannst auf globale Variablen und Funktionen innerhalb desselben Skripts zugreifen, jedoch nicht zwischen mehreren Skripten. Daher bietet eine globale Variable oder Funktion keinen Vorteil gegenüber einem lokalen Äquivalent im Gültigkeitsbereich, einer Upvalue oder einem Shadow.

Lokaler Gültigkeitsbereich

Luau kann nur auf eine lokale Variable oder Funktion in dem Codeblock zugreifen, in dem du sie deklarierst. Eine Variable mit lokalem Gültigkeitsbereich gibt dir eine genauere Kontrolle darüber, wann und wo sich ihr Wert ändert.

Im folgenden Code haben die Funktion testFunc() und die Variable testVar lokalen Gültigkeitsbereich. Nur der Code innerhalb von testFunc() kann auf die Variable testVar zugreifen. Die Variable testVar hat außerhalb von testFunc() keinen Wert, sodass der Aufruf von print(testVar) innerhalb von testFunc() den Wert von testVar ausgibt, während der Aufruf von print(testVar) außerhalb von testFunc() nil ausgibt.

local function testFunc()  -- lokaler Gültigkeitsbereich
	local testVar = 64  -- lokaler Gültigkeitsbereich
	print(testVar) -- 64
end

testFunc()

print(testVar) -- nil

Im folgenden Code hat die lokale Variable x an Zeile 1 den Wert 0. Während Luau durch die for-Schleife iteriert, hat eine andere lokale Variable x den Wert 1. Dann gibt Luau die ursprüngliche Variable x mit einem unveränderten Wert 0 aus.

local x = 0  -- Lokale Variable "x"

for i = 1, 4 do
	local x = 1  -- Verschiedene Variable "x", lokal zu dieser "for" Schleife
	print("Schleifen-'x' = " .. x)
end

print("Ursprüngliches 'x' = " .. x)

--[[ Ergebnisausgabe:
Schleifen-'x' = 1
Schleifen-'x' = 1
Schleifen-'x' = 1
Schleifen-'x' = 1
Ursprüngliches 'x' = 0
]]

Erfassen

Nachdem du eine lokale Variable deklariert und zugewiesen hast, kannst du sie in ihrem Gültigkeitsbereich und in Funktionen lesen, deren Gültigkeitsbereiche in den gleichen Gültigkeitsbereich eingekapselt sind, der die lokale Variable enthält. Diese Technik wird als Erfassen bezeichnet.

Im folgenden Code erfasst die Funktion f die lokale Variable x. Die Variable x in f() ist eine Upvalue.

local x = 5

local function f()
	print(x)
end

f() -- 5
print(x) -- 5

Schatten

Nachdem du eine lokale Variable deklariert und zugewiesen hast, kannst du sie in ihrem Gültigkeitsbereich und in Nachfolgenden Gültigkeitsbereichen lesen. Wenn du die Variable in einem Nachfolgenden Gültigkeitsbereich erneut deklarierst und zuweist, erstellst du eine neue lokale Variable mit demselben Namen, aber einem anderen Wert als der letzten Zuweisung. Die neue lokale Variable beeinflusst nicht die lokale Variable aus der vorherigen Zuweisung. Diese Technik, bekannt als Schatten, hilft dir, den Namen einer Variable wiederzuverwenden, ohne ihren Wert erneut zu verwenden.

Im folgenden Code schattet Luau die Variable x. Die Variable x in f() ist eine Schatten-Variable.

local x = 5

local function f()
	local x = 7
	print(x)
end

f() -- 7
print(x) -- 5

Du kannst auch eine lokale Variable neu deklarieren, ohne ihr einen Wert zuzuweisen, sodass du die Variable sowohl in ihrem Gültigkeitsbereich als auch in den Nachfolgenden Gültigkeitsbereichen neu zuweisen kannst. Eine Neudeklaration einer lokalen Variable ohne Wertzuweisung setzt ihren Wert auf nil.

Im folgenden Code schattet Luau die lokale Variable fruitName in der Funktion getFruitByColor(). Die Funktion deklariert fruitName als neue Schattenvariable und setzt ihren Wert auf nil. Die Funktion hat einen nachfolgenden Gültigkeitsbereich, eine for-Schleife, die der fruitName einen Wert zuweist. Nach der for-Schleife gibt die Funktion die fruitName-Schattenvariable zurück. Während der gesamten Funktion ist fruitName die gleiche lokale Variable, die die ursprüngliche lokale Variable fruitName nicht überschreibt.

local fruitName = "Schokolade"
local fruitTable = {
	Zitrone = "Gelb",
	Apfel = "Rot",
	Orange = "Orange"
}

local function getFruitByColor(color)
	local fruitName
	for key, value in fruitTable do
		if value == color then
			fruitName = key
		end
	end
	return fruitName
end

local fruit = getFruitByColor("Gelb")
print(fruit) -- Zitrone
print(fruit .. ", nicht " .. fruitName) -- Zitrone, nicht Schokolade