Luau-Cheatsheet
Prüfmodi
Ein Kommentar in der ersten Zeile entscheidet, wie streng Luau prüft.
| Modus | Syntax |
|---|---|
| Keine Typprüfung | --!nocheck |
| Standard: prüft Annotiertes | --!nonstrict |
| Strict: leitet ab und prüft alles | --!strict |
| Datei ausführen | luau main.luau |
| Typen prüfen ohne Ausführen | luau-analyze main.luau |
| Eine Lint-Warnung abschalten | --!nolint UnknownGlobal |
Basistypen
Die primitiven Typen und wie du eine Variable annotierst.
| Operation | Syntax |
|---|---|
| Zahl | local age: number = 25 |
| String | local name: string = "Ada" |
| Boolean | local ok: boolean = true |
| Optional (kann nil sein) | local nick: string? = nil |
| Any (keine Prüfung) | local x: any = f() |
| Unknown (sicheres any) | local x: unknown = f() |
| Never (wirft immer) | function fail(): never error("boom") end |
| Nil | local n: nil = nil |
| Coroutine / Buffer | local co: thread, local b: buffer |
| Abgeleitet - keine Annotation nötig | local hp = 100 -- number |
Typisierte Tabellen: Arrays & Maps
Es bleiben Lua-Tabellen - der Typ sagt, was drin ist.
| Operation | Syntax |
|---|---|
| Array von Zahlen | local xs: {number} = {1, 2, 3} |
| Array von Strings | local names: {string} = {} |
| Map (String-Schlüssel) | local ages: {[string]: number} = {} |
| Map (beliebiger Schlüsseltyp) | local seen: {[Player]: boolean} = {} |
| Verschachteltes Array | local grid: {{number}} = {} |
| Array von Formen | local items: {{id: number}} = {} |
| Nur-Lese-Array | local t = table.freeze({1, 2, 3}) |
| Iterieren (generalisiert, nur Luau) | for i, v in xs do print(i, v) end |
| Schlüssel und Werte iterieren | for k, v in pairs(ages) do end |
Funktionen
Annotiere Parameter und Rückgabetyp; -> () heißt: gibt nichts zurück.
| Operation | Syntax |
|---|---|
| Typisierte Parameter + Rückgabe | function add(a: number, b: number): number |
| Gibt nichts zurück | function log(msg: string): () end |
| Mehrere Rückgaben | function split(s: string): (string, string) |
| Optionaler Parameter | function greet(name: string?) end |
| Standardwert | function greet(name: string?) name = name or "friend" end |
| Variadisch | function sum(...: number): number end |
| Anonyme Funktion | local f = function(x: number): number return x * 2 end |
| Funktionstyp | type Adder = (number, number) -> number |
| Callback-Parameter | function each(f: (number) -> ()) end |
Typaliase, Unions & Literale
Einen Typ einmal benennen und überall wiederverwenden.
| Operation | Syntax |
|---|---|
| Alias für ein Primitiv | type Health = number |
| Union | type Id = number | string |
| Optional = Union mit nil | type Maybe = string | nil -- same as string? |
| Literaltyp (Singleton) | type Dir = "up" | "down" |
| Intersection | type Both = Named & Aged |
| Generischer Alias | type List<T> = {T} |
| Aus einem Modul exportieren | export type Point = { x: number, y: number } |
| Typ eines vorhandenen Werts | type Config = typeof(config) |
| Schlüssel eines Tabellentyps | type K = keyof<Point> |
Tabellenformen & Methoden
Objekte beschreiben - und das self, das mit Doppelpunkt-Aufrufen kommt.
| Operation | Syntax |
|---|---|
| Inline-Form | local p: { x: number, y: number } = { x = 0, y = 0 } |
| Benannte Form | type Point = { x: number, y: number } |
| Optionale Eigenschaft | type User = { name: string, age: number? } |
| Form + Indexer | type Bag = { count: number, [string]: any } |
| Form erweitern | type Admin = User & { level: number } |
| Methode (Doppelpunkt-Kurzform) | function Point.move(self: Point, dx: number) end |
| Methode in einem Typ | type Point = { move: (self: Point, dx: number) -> () } |
| Konstruktor-Muster | function Point.new(x: number): Point end |
| Eingefrorene Konstanten (enum-artig) | local Color = table.freeze({ Red = 1, Blue = 2 }) |
Generics
Eine Funktion oder ein Typ für viele Wertetypen.
| Operation | Syntax |
|---|---|
| Generische Funktion | function id<T>(x: T): T return x end |
| Zwei Typparameter | function pair<A, B>(a: A, b: B): (A, B) end |
| Generisch über ein Array | function first<T>(xs: {T}): T? return xs[1] end |
| Generischer Typalias | type Stack<T> = { items: {T} } |
| Alias instanziieren | local s: Stack<string> = { items = {} } |
| Generische map-Funktion | function map<T, U>(xs: {T}, f: (T) -> U): {U} end |
| Generisches Pack (variadisch) | function call<T...>(f: () -> T...): T... end |
Narrowing, Casts & Guards
Den Typprüfer davon überzeugen, dass ein Wert das ist, was du weißt.
| Operation | Syntax |
|---|---|
| Typumwandlung (Cast) | local n = value :: number |
| Cast über any | local n = (value :: any) :: number |
| Mit typeof einengen | if typeof(x) == "string" then -- x is string end |
| Optional einengen | if name then print(#name) end |
| Früher Return bei nil | if not name then return end |
| Literal-Union einengen | if dir == "up" then end |
| Laufzeitprüfung | assert(typeof(id) == "number", "id must be a number") |
| Nicht-nil sichern und nutzen | local item = assert(find(id), "missing item") |
Operatoren & Syntax, die Lua fehlen
Die alltäglichen Annehmlichkeiten - hier hört Luau-Code auf, wie Lua auszusehen.
| Operation | Syntax |
|---|---|
| Addieren und zuweisen | hp += 10 |
| Subtrahieren / multiplizieren / dividieren | hp -= 5, dmg *= 2, dmg /= 2 |
| Ganzzahldivision und zuweisen | n //= 2 |
| Modulo / Potenz und zuweisen | n %= 3, n ^= 2 |
| Verketten und zuweisen | msg ..= "!" |
| Ganzzahldivision | local half = 7 // 2 -- 3 |
| String-Interpolation | Hello, {name}! You have {n} items. (in Backticks setzen) |
| Ausdruck interpolieren | Total: {price * qty} (in Backticks setzen) |
| Schleife fortsetzen | for _, v in xs do if v < 0 then continue end end |
| if-then-else-Ausdruck | local label = if hp > 0 then "alive" else "dead" |
| Verketteter else-if-Ausdruck | local t = if n > 0 then "pos" elseif n < 0 then "neg" else "zero" |
| Binär- / getrennte Zahlenliterale | 0b1010, 1_000_000 |
Bibliotheks-Extras & Lua-Unterschiede
Funktionen, die Luau der Standardbibliothek hinzufügt, und Lua-Features, die es entfernt.
| Punkt | Detail |
|---|---|
| Wert in einem Array finden | table.find(xs, 42) -- Index oder nil |
| Flache Kopie | local copy = table.clone(t) |
| Unveränderlich machen / prüfen | table.freeze(t), table.isfrozen(t) |
| Array vorbelegen | table.create(10, 0) |
| Clamp / round / sign | math.clamp(x, 0, 1), math.round(x), math.sign(x) |
| Bit-Operationen | bit32.band(a, b), bit32.lshift(a, 1) |
| Aus Sandboxing-Gründen entfernt | io, package, loadstring, loadfile, dofile |
| Veraltet, aber vorhanden | getfenv, setfenv (deaktivieren Optimierungen) |
| Nicht in Luau | goto / Labels (Luau basiert auf Lua 5.1) |
| stdin auf Coddy lesen | io.read() funktioniert hier - Coddy stellt es über Luau bereit |
| Dateiendung | main.luau (.lua geht auch) |
| Nur Roblox, nicht Kern-Luau | game, workspace, Instance.new, task.wait |
Luau ist Lua 5.1 plus graduelles Typsystem - die Sprache, die Roblox entwickelt und als Open Source freigegeben hat. Dieses Cheatsheet deckt das ab, was *nicht* einfaches Lua ist: Typannotationen, typisierte Tabellen, Unions und Literaltypen, Generics, Typumwandlungen und den Syntax-Zucker von Luau (+=, String-Interpolation, continue, if-then-else-Ausdrücke). Für alles, was beide Sprachen teilen - Tabellen, Metatabellen, Coroutinen, die String-Bibliothek - halte das Lua-Cheatsheet daneben offen.
Alles hier ist Standard-Luau, ausführbar mit dem luau-CLI und prüfbar mit luau-analyze. Kopiere, was du brauchst, oder probiere es live im Luau-Playground - ohne Installation. Neu beim Typsystem? Coddys kostenloser interaktiver Luau-Kurs baut es Lektion für Lektion auf.
FAQ zum Luau-Cheatsheet
Ist dieses Luau-Cheatsheet kostenlos?
Ja. Dieses Luau-Cheatsheet ist völlig kostenlos und ohne Anmeldung nutzbar. Setz ein Lesezeichen für das nächste Mal, wenn du die Syntax einer Union, eines Generics oder einer typisierten Tabelle brauchst.
Hat Luau einen +=-Operator?
Ja. Anders als reines Lua unterstützt Luau zusammengesetzte Zuweisungen:
+=, -=, *=, /=, //=, %=, ^= und ..= für String-Verkettung. hp += 10 ist also gültiges Luau (und gültiger Roblox-Code), während man in Lua 5.1 hp = hp + 10 schreiben muss. Beachte: ++ und -- gibt es in Luau nicht.Was ist der Unterschied zwischen Lua und Luau?
Luau ist eine Obermenge von Lua 5.1 mit graduellem Typsystem. Zusätzlich zu Typen bringt es String-Interpolation mit Backticks, zusammengesetzte Zuweisungsoperatoren,
continue, if-then-else-Ausdrücke, Ganzzahldivision //, generalisierte Iteration (for i, v in t do) und Funktionen wie table.find, table.clone und table.freeze. Aus Sandboxing-Gründen fehlen loadstring, loadfile, dofile sowie die Bibliotheken io und package; goto gibt es nicht, weil Luau auf 5.1 basiert. Normaler Lua-Code läuft meist unverändert als Luau.Wie schalte ich die Typprüfung in Luau ein?
Setze einen Modus-Kommentar in die erste Zeile:
--!strict prüft alles und leitet aggressiv ab, --!nonstrict (Standard) prüft nur Annotiertes, --!nocheck schaltet die Prüfung aus. Außerhalb des Editors prüfst du mit luau-analyze main.luau ohne Ausführung und führst mit luau main.luau aus.Schreibt man in Luau interface wie in TypeScript?
Nein - Luau hat kein
interface-Schlüsselwort. Objektformen schreibt man als Tabellentypen und benennt sie mit type: type User = { name: string, age: number? }. Kombiniere Formen mit & statt extends, und nutze export type, um sie anderen Modulen bereitzustellen.Ist dieses Cheatsheet dasselbe wie Roblox-Scripting?
Alles hier ist Kern-Luau - die Sprache - gilt also für Roblox-Skripte genauso wie für eigenständiges Luau. Was *nicht* hier steht, ist die Roblox-Engine-API (
game, workspace, Instance.new, Services, Events): eine Bibliothek auf der Sprache, dokumentiert von Roblox, nicht von Luau.Wo kann ich diese Luau-Snippets ausführen?
Im Luau-Playground - er führt den echten
luau-Interpreter im Browser aus, mit stdin-Unterstützung. Du kannst also jede Zeile dieser Seite einfügen und auf Ausführen drücken. Für strukturierte Praxis behandelt der interaktive Luau-Kurs dasselbe Material mit Übungen, Projekten und Zertifikat.Verwandte Ressourcen
Weitere Spickzettel
