Variablen & Datentypen in Lua

Lua hat erstaunlich wenige Typen - nur acht Stueck. Das macht die Sprache klein und lernbar.

Die acht Typen

type(nil)        -- "nil"
type(true)       -- "boolean"
type(42)          -- "number"
type("text")     -- "string"
type({})          -- "table"
type(print)       -- "function"
type(userdata)   -- "userdata" (C-Objekte)
type(co)          -- "thread" (Coroutinen)

Du wirst primaer fuenf davon nutzen: nil, boolean, number, string, table.

`nil` - der leere Wert

local x = nil
local y                   -- auch nil (nicht initialisiert)

print(x)                  -- nil
print(x == nil)           -- true
print(not x)               -- true (nil ist falsy)

Nur nil und false sind falsy. Alles andere ist truthy - auch 0, "", {}:

if 0 then print("truthy!") end   -- wird ausgegeben
if "" then print("truthy!") end  -- wird auch ausgegeben

Boolean

local aktiv = true
local fertig = false

Number

Seit Lua 5.3 gibt es Integer und Float als Subtypen:

local i = 42           -- integer
local f = 3.14         -- float

print(math.type(i))    -- "integer"
print(math.type(f))    -- "float"

print(1 // 2)          -- 0 (integer division)
print(1 / 2)           -- 0.5 (float division)

Numbers sind standardmaessig 64-Bit (double / int64).

Wichtige Math-Funktionen

math.pi            -- 3.1415...
math.abs(-5)       -- 5
math.max(1, 2, 3)  -- 3
math.min(1, 2, 3)  -- 1
math.floor(3.7)    -- 3
math.ceil(3.2)     -- 4
math.random()      -- 0..1
math.random(10)    -- 1..10
math.random(1, 100) -- 1..100

String

Strings sind unveraenderlich in Lua:

local s = "Hallo"
local s2 = 'auch moeglich'
local s3 = [[
mehrzeilig
ohne Escaping
]]

Wichtige String-Methoden

local s = "Hallo Welt"

#s                     -- 10 (Laenge)
s:upper()              -- "HALLO WELT"
s:lower()              -- "hallo welt"
s:sub(1, 5)            -- "Hallo"
s:sub(-4)              -- "Welt"
s:find("Welt")          -- 7, 10
s:gsub("l", "L")        -- "HaLLo WeLt", 3 (replace all, count)

Der `:`-Doppelpunkt

s:upper() ist gleich string.upper(s) - der Doppelpunkt uebergibt s als erstes Argument.

`string.format`

local msg = string.format("Name: %s, Alter: %d", "Anna", 28)

Gleich wie printf in C.

String in Zahl und zurueck

tonumber("42")          -- 42
tonumber("3.14")         -- 3.14
tonumber("abc")          -- nil (misslungen)

tostring(42)             -- "42"
tostring(true)           -- "true"
tostring(nil)            -- "nil"

Table - die universelle Datenstruktur

Tables sind alles in Lua: Arrays, Dictionaries, Objekte, Namespaces.

Als Array

local zahlen = {10, 20, 30}

print(zahlen[1])       -- 10 (Index startet bei 1!)
print(zahlen[3])       -- 30
print(#zahlen)         -- 3 (Laenge)

zahlen[4] = 40         -- hinzufuegen
table.insert(zahlen, 50)   -- anhaengen
table.remove(zahlen)       -- letztes entfernen

Als Dictionary

local person = {
  name = "Anna",
  alter = 28,
  aktiv = true
}

print(person.name)      -- "Anna"
print(person["name"])   -- "Anna" (gleich)

person.email = "anna@example.com"
person.alter = 29

Gemischte Tables

local bunt = {
  "erstes",           -- index 1
  "zweites",          -- index 2
  name = "Anna",      -- key "name"
  42                  -- index 3
}

Das ist maechtig - aber selten in dieser Form sinnvoll.

Ueber Tables iterieren

-- Array-Teil mit ipairs
for i, v in ipairs(zahlen) do
  print(i, v)
end

-- Dictionary-Teil mit pairs
for key, value in pairs(person) do
  print(key, value)
end

ipairs iteriert nur ueber den Array-Teil (1, 2, 3, …), stoppt beim ersten nil
pairs iteriert ueber alles, inklusive String-Keys

Function

Funktionen sind Werte:

local addieren = function(a, b) return a + b end

-- gleichwertig mit:
local function addieren(a, b) return a + b end

Du kannst sie in Variablen speichern, weitergeben, zurueckgeben.

Lokale vs. globale Variablen

x = 42              -- global (speichert in _G.x)
local y = 42        -- lokal (block-scoped)

Fast immer lokal! Globale Variablen haben Performance-Nachteile und verursachen Namenskonflikte.

Scope

local x = 1
do
  local x = 2       -- neuer Scope, neue x
  print(x)          -- 2
end
print(x)            -- 1

Lokale Variablen gelten bis zum Ende des umschliessenden Blocks (do/end, if/end, function/end, File-Ende).

Mehrere Zuweisungen

local a, b, c = 1, 2, 3
local x, y = y, x           -- Tausch

local erste, rest = "a", "b"  -- erste="a", rest="b"

Bei weniger Werten werden restliche Variablen nil:

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

Der `nil`-Trick

Zum Loeschen von Table-Eintraegen:

person.email = nil     -- entfernt den Key "email"

Konstanten

Lua 5.4 bringt endlich <const>:

local PI <const> = 3.14159
-- PI = 3.0   -- FEHLER: attempt to assign to const variable

In aelteren Versionen ist Konvention: Uppercase-Namen sind “konstant” - aber nicht erzwungen:

local MAX_RETRIES = 5

Der `to`-Laden

tonumber("42")         -- 42
tonumber("0xff", 16)   -- 255 (mit Basis)
tostring(42)           -- "42"
tostring(true)         -- "true"
tostring(nil)          -- "nil"
tostring({})           -- "table: 0x..." (Adresse)

Praktisches Beispiel

local function nutzer_beschreiben(data)
  local name = data.name or "Anonym"
  local alter = data.alter
  local rollen = data.rollen or {}

  local alter_text = alter and (alter .. " Jahre") or "Alter unbekannt"
  local rollen_text = #rollen == 0 and "keine Rollen" or table.concat(rollen, ", ")

  return string.format("%s (%s) - %s", name, alter_text, rollen_text)
end

print(nutzer_beschreiben({
  name = "Anna",
  alter = 28,
  rollen = {"admin", "editor"}
}))

print(nutzer_beschreiben({ alter = 22 }))

Der `and`/`or`-Trick

Lua’s and und or liefern Werte zurueck, nicht nur Booleans:

local x = a or b      -- a, wenn truthy, sonst b (Default)
local y = a and b     -- b, wenn a truthy, sonst a

Das ersetzt oft den ternaeren Operator, den Lua nicht hat:

local text = alter and "dabei" or "fehlt"

Zusammenfassung

Acht Typen, im Alltag nutzt du fuenf: nil, boolean, number, string, table
Nur nil und false sind falsy - 0 und "" sind truthy
Tables sind alles: Array, Dictionary, Objekt, Namespace
Arrays starten bei 1, #t liefert die Laenge
Immer local - globale Variablen sind selten gewollt
and/or liefern Werte, nicht nur Booleans - nuetzlich fuer Defaults

Im naechsten Kapitel: Kontrollstrukturen.