In Scriptingist ein Block Code der Körper einer Kontrollstruktur oder Funktion.Der Umfang einer Variable oder Funktion ist der Block Code, der auf sie 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, aber nicht in einem seiner Kindblöcke.
Variablen und Funktionen haben standardmäßig globale Reichweite, aber es ist fast immer besser, sie mit lokaler Reichweite zu deklarieren, weil Luau lokale Variablen und Funktionen schneller als globale zugreift.Um einer Variable oder Funktion lokalen Umfang zu geben, stelle das Schlüsselwort local vor ihren Namen, wenn du sie erklärst.
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 = 'Hello World!'
local function printHelloWorld()
print(helloWorld)
end
printHelloWorld() -- Hello World!
- Block B kann auf die lokale Variable im Block A zugreifen.
- Block C kann auf lokale Variablen und Funktionen in Blöcken A und B zugreifen.
- Block A kann nicht auf lokale Variablen und Funktionen in Blöcken B oder C zugreifen.
- Block B kann nicht auf die lokale Variable im Block C zugreifen.
Globale Reichweite
Nachdem du eine globale Variable oder Funktion deklariert hast, kann jeder Block Code in demselben Skript darauf zugreifen.Variablen und Funktionen haben globale Reichweite, es sei denn, du erklärst sie mit dem Schlüsselwort local.
Im folgenden Codeshat testVar globale Reichweite innerhalb der lokalen testFunc()-Funktion.Wenn Luau die testFunc() anruft, weist es testVar den Wert 64 zu.Die testVar hat globale Reichweite, so kann die print() Funktion außerhalb von testFunc() darauf zugreifen und drucken 64 .
Example of global functions and variables
local function testFunc() -- lokaler umfang
testVar = 64 -- globaler umfang
end
testFunc()
print(testVar) -- 64
Im folgenden Codesbeginnt die globale Variable bei und erhöht sich bei jeder Iteration der Schleife um , druckt dann erneut mit einem endgültigen Wert von 4.
Es ist einfacher, globale Variablen und Funktionen zu deklarieren, weil du nicht so viel tippen musst, aber globale Variablen und Funktionen haben die folgenden Nachteile im Vergleich zu lokalen:
- Luau greift globale Variablen und Funktionen mit einer Hash-Suche zu, so dass es teuer ist, in Bezug auf die Erfüllungzu verwenden.Die Verwendung einer globalen Variablen in einem zeitkritischen Schleifen kann dazu führen, dass er mehr als 10% langsamer ist als die Verwendung einer lokalen Variable im gleichen Schleifen.
- Luau entsorgt lokale Variablen, nachdem ihr Umfang abgelaufen ist, und reduziert die Speicherverwendung.
- Du kannst globale Variablen und Funktionen innerhalb desselben Skript, das. PL: die Skriptszugreifen, aber nicht zwischen mehreren Skripten.Daher bietet eine globale Variable oder Funktion keinen Vorteil gegenüber einem lokalen Äquivalent in Reichweite, einem Aufwertungswert oder einem Schatten.
Lokaler Umfang
Luau kann nur auf eine lokale Variable oder Funktion im Block des Codes zugreifen, in dem du sie deklarierst.Die Erstellung einer Variable mit lokaler Reichweite gibt dir eine engere Kontrolle darüber, wann und wo sich ihr Wert ändert.
Im folgenden Codeshaben die Funktion testFunc() und die Variable testVar lokalen Umfang.Nur der Code innerhalb von testFunc() kann auf die testVar Variable zugreifen.Die Variable testVar hat keinen Wert außerhalb von testFunc(), so dass das Aufrufen von print(testVar) innerhalb von testFunc() den Wert von testVar druckt, aber das Aufrufen von print(testVar) außerhalb von testFunc() druckt nil .
local function testFunc() -- lokaler umfang
local testVar = 64 -- lokaler umfang
print(testVar) -- 64
end
testFunc()
print(testVar) -- nil
Im folgenden Codeshat die lokale Variable x den Wert 0 in der Zeile 1.Während Luau durch die for Schleife iteriert, hat eine andere lokale Variable x einen Wert 1 .Dann druckt Luau die anfängliche Variable x mit einem unveränderten Wert 0 aus.
Einfangen
Nachdem du eine lokale Variable deklariert und zugewiesen hast, kannst du sie auf ihrer Ebene lesen und ihre Funktionen, deren Umfang durch die gleiche Ebene enthalten ist, die die lokale Variable enthält.Diese Technik wird als Einfang bekannt.
Im folgenden Codeserfängt die Funktion f die lokale Variable x.Die Variable x in f() ist ein Oberwert .
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 auf ihrer Ebene und auf Ebenen ihrer Abkömmlinge lesen.Wenn du die Variable in einem untergeordneten Stufeneu deklarierst und neu zuweist, erstellst du eine neue lokale Variable mit demselben Namen, aber einem anderen Wert als die zuvor zugewiesene Zuordnung.Die neue lokale Variable wirkt sich nicht auf die lokale Variable aus der vorherigen Zuweisung aus.Diese Technik, die als Shadowing bekannt ist, hilft dir, den Namen einer Variablen wiederzuverwenden, ohne ihren Wert wiederzuverwenden.
Im folgenden Codesschattiert 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, so dass du die Variable sowohl auf ihrer Ebene als auch auf den Ebenen ihrer Abkömmlinge wiederzuweisen kannst.Die Wiedererklärung einer lokalen Variable ohne ihr einen Wert zuzuweisen, legt ihren Wert auf nil fest.
Im folgenden Codesschattiert Luau die lokale Variable fruitName in der Funktion getFruitByColor().Die Funktion deklariert fruitName erneut als neue Schattenvariable und legt ihren Wert auf nil fest.Die Funktion hat ein Stufe, eine for Schleife, die einen Wert zu fruitName.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 fruitName lokale Variable nicht überschreibt.
local fruitName = "Chocolate"
local fruitTable = {
Lemon = "Yellow",
Apple = "Red",
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("Yellow")
print(fruit) -- Zitrone
print(fruit .. ", not " .. fruitName) -- Lemon, not Chocolate