Gültigkeitsbereich

In der Skripterstellung ist ein Codeblock der Körper einer Steuerstruktur oder Funktion. Der Gültigkeitsbereich 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 in seinem übergeordneten Block zugreifen, jedoch nicht in einem seiner untergeordneten Blöcke.

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

Skripte können nicht auf globale und lokale Variablen oder Funktionen in anderen Skripten zugreifen. Wenn Sie Werte und Funktionen zwischen Skripten teilen möchten, verwenden Sie 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 Sie eine globale Variable oder Funktion deklariert haben, kann jeder Codeblock im selben Skript darauf zugreifen. Variablen und Funktionen haben globalen Gültigkeitsbereich, es sei denn, Sie deklarieren sie mit dem Schlüsselwort local.

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

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 wird danach erneut mit einem Endwert von 4 ausgegeben.

x = 0  -- Globale Variable "x"

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

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

--[[ Ergebnis:
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 Sie nicht so viel tippen müssen, aber globale Variablen und Funktionen haben im Vergleich zu lokalen folgende Nachteile:

• Luau greift auf globale Variablen und Funktionen mit einer Hash-Suche zu, was in Bezug auf die Leistung teuer ist. Die Verwendung einer globalen Variable in einer zeitkritischen Schleife kann dazu führen, dass sie mehr als 10 % langsamer ist als die Verwendung einer lokalen Variable in derselben Schleife.
• Luau gibt lokale Variablen nach dem Ende ihres Gültigkeitsbereichs frei, was den Speicherverbrauch reduziert.
• Sie können 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 einer lokalen Entsprechung im Gültigkeitsbereich, einem Upvalue oder einem Schatten.

Lokaler Gültigkeitsbereich

Luau kann nur auf eine lokale Variable oder Funktion im Codeblock zugreifen, in dem Sie sie deklarieren. Das Erstellen einer Variablen mit lokalem Gültigkeitsbereich gibt Ihnen eine engere Kontrolle darüber, wann und wo sich ihr Wert ändert.

Im folgenden Code haben die Funktion testFunc() und die Variable testVar einen 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 in 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 dem unveränderten Wert 0 aus.

local x = 0  -- Lokale Variable "x"

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

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

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

const-Variablen und -Funktionen folgen denselben Gültigkeitsbereichsregeln wie local. Sie können sie in jedem Block deklarieren, auch innerhalb einer anderen Funktion. Weitere Informationen zu const finden Sie unter Const-Variablen.

Erfassen

Nachdem Sie eine lokale Variable deklariert und zugewiesen haben, können Sie sie in ihrem Gültigkeitsbereich und in Funktionen lesen, deren Gültigkeitsbereich den Gültigkeitsbereich enthält, 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 ein Upvalue.

local x = 5

local function f()
	print(x)
end

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

Schatten

Nachdem Sie eine lokale Variable deklariert und zugewiesen haben, können Sie sie in ihrem Gültigkeitsbereich und in den Gültigkeitsbereichen der Nachkommen lesen. Wenn Sie die Variable in einem Nachkommen-Gültigkeitsbereich neu deklarieren und neu zuweisen, erstellen Sie 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, die als Schatten bekannt ist, hilft Ihnen, den Namen einer Variablen wiederzuverwenden, ohne ihren Wert wiederzuverwenden.

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

Sie können auch eine lokale Variable neu deklarieren, ohne ihr einen Wert zuzuweisen, sodass Sie die Variable sowohl in ihrem Gültigkeitsbereich als auch in den Gültigkeitsbereichen der Nachkommen neu zuweisen können. Das Neudeklarieren einer lokalen Variable ohne Zuweisung eines Wertes 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 Nachkommen-Gültigkeitsbereich, eine for-Schleife, die einen Wert an fruitName zuweist. Nach der Schleife gibt die Funktion die Schattenvariable fruitName zurück. Während der gesamten Funktion ist fruitName dieselbe 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