0Pricing
Lua Academy · Lektion

Variablen in Lua deklarieren

Verstehen Sie globale und lokale Variablen sowie Namenskonventionen.

Variablen in Lua deklarieren ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Globale und lokale Variablen

In Lua sind Variablen standardmäßig global. Wenn Sie ohne das Schlüsselwort local x = 10 schreiben, erstellen Sie eine globale Variable, auf die von überall aus zugegriffen werden kann. Mit local x = 10 beschränken Sie die Variable auf den aktuellen Block und dessen verschachtelte Blöcke.

Verwenden Sie aus Gründen der Leistung und Sicherheit grundsätzlich local. Der Zugriff auf eine lokale Variable ist schneller als auf eine globale, da globale Variablen eine Hashtabellen-Suche in der Tabelle _G erfordern.

x = 100          -- global variable
local y = 200    -- local variable

do
  local z = 300  -- block-local
  print(x, y, z) -- 100  200  300
end

print(x, y)      -- 100  200
print(z)         -- nil  (out of scope)

Das Schlüsselwort local

Das Schlüsselwort local deklariert eine Variable, deren Gültigkeitsbereich auf den nächstgelegenen umschließenden Block beschränkt ist: den Funktionskörper, einen do...end-Block, den Schleifenkörper oder einen Datei-Chunk. Lokale Variablen werden in der Zeile erstellt, in der sie deklariert werden, und existieren am Ende ihres Blocks nicht mehr.

Sie können mehrere lokale Variablen in einer Zeile deklarieren und gleichzeitig initialisieren. Nicht initialisierte lokale Variablen erhalten standardmäßig den Wert nil.

local a, b, c = 1, 2, 3
print(a, b, c)    -- 1  2  3

local d, e = 10   -- e is nil
print(d, e)       -- 10  nil

local f           -- nil until assigned
f = 42
print(f)          -- 42

Konventionen für Variablennamen

Für Lua-Bezeichner gelten folgende Regeln: Sie müssen mit einem Buchstaben oder Unterstrich beginnen, gefolgt von Buchstaben, Ziffern oder Unterstrichen. Lua unterscheidet zwischen Groß- und Kleinschreibung, daher sind Value, value und VALUE drei verschiedene Variablen.

Als Konvention gilt: Verwenden Sie camelCase oder snake_case für gewöhnliche Variablen, UPPER_CASE für Konstanten und stellen Sie privaten Modulfeldern einen Unterstrich voran. Vermeiden Sie einbuchstabige Namen, außer für Schleifenzähler.

local myVariable = 1     -- camelCase
local my_variable = 2    -- snake_case
local MAX_SIZE = 100     -- constant convention
local _private = "hidden" -- private convention

-- Case sensitivity demo
local lua = "lower"
local Lua = "upper"
print(lua, Lua)  -- lower  upper

Die globale Tabelle _G

Alle globalen Variablen in Lua befinden sich in einer speziellen Tabelle namens _G. x = 10 zu schreiben entspricht _G.x = 10. Sie können alle globalen Variablen untersuchen, indem Sie über _G iterieren. Das ist beim Debuggen praktisch, für Produktivcode jedoch riskant.

In Lua 5.2+ ist _ENV die eigentliche Umgebungstabelle, und _G wird so initialisiert, dass es auf diese Tabelle zeigt. Wenn Sie das verstehen, können Sie Code durch Ersetzen von _ENV in einer Sandbox ausführen.

myGlobal = 42
print(_G.myGlobal)   -- 42

-- Setting via _G is the same as direct assignment
_G.another = "hello"
print(another)        -- hello

-- Counting globals (many built-ins exist)
local count = 0
for k in pairs(_G) do count = count + 1 end
print("Globals:", count)

Mehrfachzuweisung

Lua unterstützt Mehrfachzuweisungen: Sie können mehrere Variablen in einer einzigen Anweisung zuweisen. Die rechte Seite wird zuerst ausgewertet und anschließend von links nach rechts zugewiesen. Gibt es mehr Variablen als Werte, erhalten die zusätzlichen Variablen nil. Gibt es mehr Werte als Variablen, werden die zusätzlichen Werte verworfen.

Dadurch lassen sich Variablen ohne temporäre Variable problemlos vertauschen.

-- Swap without temp variable
local a, b = 10, 20
a, b = b, a
print(a, b)   -- 20  10

-- More variables than values
local x, y, z = 1, 2
print(x, y, z)  -- 1  2  nil

-- More values than variables
local p, q = 1, 2, 3  -- 3 is discarded
print(p, q)   -- 1  2

Gültigkeitsbereiche und Blockgrenzen

Die Blockbegrenzer von Lua sind: do...end, Funktionskörper, if/elseif/else...end, while...end, repeat...until und for...end. Jeder davon erzeugt eine neue Ebene des Gültigkeitsbereichs. do...end-Blöcke sind besonders nützlich, wenn Sie den Gültigkeitsbereich ohne weitere Logik begrenzen möchten.

Eine lokale Variable, die im Kopf einer for-Schleife deklariert wird, gilt für den Schleifenkörper — sie ist außerhalb der Schleife nicht sichtbar.

for i = 1, 3 do
  local msg = "item " .. i
  print(msg)
end
-- print(i)   -- would be nil, i is gone
-- print(msg) -- would be nil, msg is gone

-- do...end for manual scoping
do
  local temp = expensive_computation or 0
  print(temp)
end
-- temp is nil here

Konstanten: Die local-Konvention

Lua hat kein integriertes Schlüsselwort const. Als Konvention verwendet man Namen in UPPER_CASE und local, um zu signalisieren, dass sich ein Wert nicht ändern sollte. Wenn Sie Konstanten am Anfang eines Moduls als lokale Variablen platzieren, erhält der JIT-Compiler außerdem einen Hinweis darauf, dass diese Werte unverändert bleiben.

Für echte Unveränderlichkeit können Sie eine Proxy-Tabelle mit __newindex verwenden, die bei einer Änderung einen Fehler auslöst — das behandeln wir in der Lektion über Metatables.

local MAX_RETRIES = 3
local PI = 3.14159265358979
local APP_VERSION = "1.0.0"

-- Use them as read-only by convention
local area = PI * 5 * 5
print(area)           -- 78.539...
print(MAX_RETRIES)    -- 3

Überschreiben von Variablen im Gültigkeitsbereich

Shadowing tritt auf, wenn ein innerer Gültigkeitsbereich eine lokale Variable mit demselben Namen wie eine äußere Variable deklariert. Die innere Deklaration erstellt eine vollständig neue Variable, die die äußere innerhalb ihres Gültigkeitsbereichs verdeckt. Die äußere Variable bleibt unverändert und wird wieder sichtbar, sobald der innere Gültigkeitsbereich endet.

Shadowing kann verwirrend sein. Bevorzugen Sie eindeutige Namen in verschachtelten Gültigkeitsbereichen; manchmal ist es jedoch beabsichtigt, beispielsweise wenn in verschachtelten Schleifen Schleifenvariablennamen wiederverwendet werden.

local x = "outer"
do
  local x = "inner"  -- shadows outer x
  print(x)            -- inner
end
print(x)              -- outer (unchanged)

local n = 10
for n = 1, 3 do       -- loop n shadows outer n
  print(n)            -- 1, 2, 3
end
print(n)              -- 10 (outer unchanged)

Globale Namensverschmutzung vermeiden

Versehentlich globale Variablen zu erzeugen, ist ein häufiger Lua-Fehler: Wenn Sie den Namen einer lokalen Variable falsch schreiben, wird stillschweigend eine neue globale Variable erstellt. Das Modul strict.lua, das häufig in Projekten eingebunden wird, erkennt nicht deklarierte globale Lese- und Schreibzugriffe, indem es eine Metatable zu _G hinzufügt.

Ein einfacherer Ansatz: Verwenden Sie immer local und führen Sie luac -p oder einen Linter wie luacheck aus, um versehentlich globale Variablen vor der Laufzeit zu erkennen.

-- Dangerous: typo creates a global silently
local counter = 0
coutner = 5  -- typo! creates global 'coutner'
print(counter)  -- 0 (not 5!)
print(coutner)  -- 5 (the typo global)

-- Fix: always use local keyword
local score = 0
score = 10  -- assigns to existing local
print(score) -- 10

Die Zuweisung von nil löscht globale Variablen

Wenn Sie einer globalen Variable nil zuweisen, wird sie aus _G entfernt und Speicher freigegeben. Das ist der richtige Weg, eine globale Variable zu „löschen“. Bei lokalen Variablen erreichen Sie denselben Effekt, indem Sie sie den Gültigkeitsbereich verlassen lassen — der Garbage Collector gibt den Speicher wieder frei.

Seien Sie vorsichtig, wenn Sie nil bei einer Mehrfachzuweisung übergeben: In bestimmten Kontexten kann dadurch die Argumentliste verkürzt werden, insbesondere bei Funktionsaufrufen auf der rechten Seite.

myGlobal = "exists"
print(myGlobal)   -- exists
print(_G.myGlobal ~= nil)  -- true

myGlobal = nil
print(myGlobal)   -- nil
print(_G.myGlobal ~= nil)  -- false
-- The entry is removed from _G

Schnelltest

Welchen Gültigkeitsbereich hat eine Variable, die mit local x = 5 im Körper einer for-Schleife deklariert wird?

Zusammenfassung: Variablen in Lua deklarieren

Die wichtigsten Erkenntnisse aus dieser Lektion:

  • Variablen sind standardmäßig global — verwenden Sie immer local
  • Lokale Variablen sind schneller (keine Hashtabellen-Suche) und sicherer
  • Mehrfachzuweisung: a, b = b, a vertauscht Werte in einer Zeile
  • Alle globalen Variablen befinden sich in _G; die Zuweisung von nil löscht sie
  • Shadowing: Ein inneres local verdeckt die äußere Variable, ohne sie zu ändern
  • Verwenden Sie nach Konvention UPPER_CASE für Konstanten

Als Nächstes: arithmetische, relationale und logische Operatoren.

Häufig gestellte Fragen

Ist die Lektion „Variablen in Lua deklarieren“ kostenlos?

Ja — der vollständige Text von „Variablen in Lua deklarieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Variablen in Lua deklarieren“?

Verstehen Sie globale und lokale Variablen sowie Namenskonventionen. Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Variablen in Lua deklarieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Überblick über Lua-Datentypen
  2. Variablen in Lua deklarieren
  3. Arithmetische und relationale Operatoren
  4. Typkoerzierung und Typkonvertierung
← Zurück zu Lua Academy