Lua Anfänger 20 min

Dein erstes Lua-Programm

Lua-Syntax im Ueberblick: print, io, Kommentare, String-Konkatenation und die ersten idiomatischen Muster.

Aktualisiert:
Inhaltsverzeichnis

Dein erstes Lua-Programm

Lua’s Einstieg ist minimalistisch - kein Boilerplate, keine Klassen, keine Imports fuer die Grundlagen.

Hallo Welt

Die minimale hallo.lua:

print("Hallo, Lua!")
lua hallo.lua
# Hallo, Lua!

Kommentare

-- Einzeiliger Kommentar

--[[
Mehrzeiliger
Kommentar
]]

Variablen - immer local nutzen

local name = "Anna"
local alter = 28
local pi = 3.14

Wichtig: Ohne local sind Variablen global! Das ist ein haeufiger Bug:

name = "Anna"      -- SCHLECHT: global
local name = "Anna"  -- GUT: lokal zum Block

Faustregel: Immer local, ausser du weisst, warum du eine globale brauchst (selten).

Strings

local name = "Anna"
local nachname = 'Mueller'       -- beides gueltig

-- Mehrzeilig mit [[ ]]
local text = [[
Mehrzeiliger Text
mit "Anfuehrungszeichen"
und ohne Escaping.
]]

Konkatenation mit ..

local name = "Anna"
local gruss = "Hallo, " .. name .. "!"
print(gruss)   -- Hallo, Anna!

Lua hat keine String-Interpolation wie Ruby oder JS. Du nutzt .. oder string.format:

local name = "Anna"
local alter = 28

print(string.format("Hallo, %s! Du bist %d Jahre alt.", name, alter))

Format-Specifiers wie in C’s printf:

  • %s - string
  • %d - integer
  • %f - float
  • %.2f - float mit 2 Nachkommastellen

Methoden-Schreibweise

local name = "anna"
print(name:upper())       -- "ANNA"
print(#name)              -- 4 (Laenge)
print(name:sub(1, 2))     -- "an"

Der Doppelpunkt : ist Lua-spezifisch - dazu kommen wir bei Tabellen/OOP.

Nutzereingabe

io.write("Wie heisst du? ")
local name = io.read()
print("Hallo, " .. name .. "!")
  • io.write - wie print ohne Zeilenumbruch
  • io.read() - liest eine Zeile

Zahlen einlesen

io.write("Dein Alter: ")
local eingabe = io.read()
local alter = tonumber(eingabe)

if alter then
  print("Mit " .. alter .. " Jahren hast du noch viel vor!")
else
  print("Das war keine gueltige Zahl.")
end

tonumber liefert nil bei ungueltigem Input - du kannst das direkt als Bedingung nutzen.

Einfache Funktionen

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

print(addieren(3, 4))   -- 7

Oder als Wert-Zuweisung (gleichwertig):

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

Beide Formen sind identisch - erstere ist haeufiger.

Mehrere Rueckgabewerte

Ein Lua-Highlight:

local function min_max(zahlen)
  local min = zahlen[1]
  local max = zahlen[1]
  for i = 2, #zahlen do
    if zahlen[i] < min then min = zahlen[i] end
    if zahlen[i] > max then max = zahlen[i] end
  end
  return min, max
end

local lo, hi = min_max({3, 1, 4, 1, 5, 9, 2})
print(lo, hi)   -- 1  9

Ein komplettes Beispiel

-- fibonacci.lua
local function fib(n)
  if n < 2 then return n end
  return fib(n - 1) + fib(n - 2)
end

io.write("Wie viele Fibonacci-Zahlen? ")
local anzahl = tonumber(io.read())

if not anzahl or anzahl <= 0 then
  print("Bitte eine positive Zahl.")
  os.exit(1)
end

local ergebnis = {}
for i = 0, anzahl - 1 do
  ergebnis[i + 1] = fib(i)
end

-- Nur das einfachste Print; richtig mit table.concat:
print(table.concat(ergebnis, ", "))

Was ist neu?

  • for i = 0, anzahl - 1 - numeric for, von 0 bis anzahl-1
  • ergebnis[i + 1] = ... - Tables haben Index 1!
  • table.concat(liste, ", ") - verbindet Elemente zu einem String

Index 1?

Ja, Lua ist eine der wenigen Sprachen mit 1-basierten Indizes. Das fuehlt sich zunaechst seltsam an, hat aber Gruende - u.a. naeher an Mathematik, und der #t-Operator (Laenge) wird einfacher:

local t = {"a", "b", "c"}
print(t[1])        -- "a"
print(t[3])        -- "c"
print(#t)          -- 3 (Laenge)

for i = 1, #t do
  print(t[i])
end

Wer aus anderen Sprachen kommt, gewoehnt sich schnell daran.

Globale vs. lokale Variablen

global_var = 42          -- global (ueberall sichtbar)
local local_var = 100    -- nur im Block

do
  local x = "innen"
  print(x)               -- "innen"
end
-- print(x) wuerde nil ausgeben (x ist ausserhalb nicht definiert)

Globale Variablen werden in der _G-Tabelle gespeichert. Sie werden nicht zur Kompilierzeit geprueft - Tippfehler werden zu neuen, unerwarteten Globals. Immer local lautet die Regel.

print("Zeile 1")        -- mit Zeilenumbruch und Tab-Trennung
print("a", "b", "c")    -- "a\tb\tc\n"

io.write("ohne Umbruch")
io.write("nah dran\n")  -- manueller Zeilenumbruch

print ist fuer schnelle Ausgabe und Debug, io.write fuer kontrollierte Ausgabe.

Shebang fuer Skripte

Unter Linux/macOS kannst du Lua-Skripte direkt ausfuehrbar machen:

#!/usr/bin/env lua

print("Hallo!")
chmod +x skript.lua
./skript.lua

Zusammenfassung

  • print und io.write fuer Ausgabe, io.read fuer Eingabe
  • .. fuer String-Konkatenation, string.format fuer Formatierung
  • Immer local vor Variablen (sonst global!)
  • Kommentare mit -- oder --[[ ]]
  • Tables haben Index 1, nicht 0
  • Mehrere Rueckgabewerte sind eingebaut

Im naechsten Kapitel: Variablen, Datentypen und die besonderen Konzepte von Lua’s Typen.

Zurück zum Lua Kurs