Luau Cheat Sheet
Modalità di controllo dei tipi
Un commento sulla prima riga del file decide quanto severamente Luau lo controlla.
| Modalità | Sintassi |
|---|---|
| Nessun controllo dei tipi | --!nocheck |
| Predefinita: controlla ciò che è annotato | --!nonstrict |
| Strict: deduce e controlla tutto | --!strict |
| Eseguire un file | luau main.luau |
| Controllare i tipi senza eseguire | luau-analyze main.luau |
| Disattivare un singolo avviso di lint | --!nolint UnknownGlobal |
Tipi di base
I tipi primitivi e come annotare una variabile.
| Operazione | Sintassi |
|---|---|
| Numero | local age: number = 25 |
| Stringa | local name: string = "Ada" |
| Booleano | local ok: boolean = true |
| Opzionale (può essere nil) | local nick: string? = nil |
| Any (esclude dal controllo) | local x: any = f() |
| Unknown (un any più sicuro) | local x: unknown = f() |
| Never (lancia sempre un errore) | function fail(): never error("boom") end |
| Nil | local n: nil = nil |
| Coroutine / buffer | local co: thread, local b: buffer |
| Dedotto: nessuna annotazione necessaria | local hp = 100 -- number |
Tabelle tipizzate: array e map
Le tabelle restano tabelle Lua: il tipo dice cosa contengono.
| Operazione | Sintassi |
|---|---|
| Array di numeri | local xs: {number} = {1, 2, 3} |
| Array di stringhe | local names: {string} = {} |
| Map (chiavi stringa) | local ages: {[string]: number} = {} |
| Map (chiavi di qualsiasi tipo) | local seen: {[Player]: boolean} = {} |
| Array annidato | local grid: {{number}} = {} |
| Array di forme | local items: {{id: number}} = {} |
| Array di sola lettura | local t = table.freeze({1, 2, 3}) |
| Iterare (generalizzato, solo Luau) | for i, v in xs do print(i, v) end |
| Iterare chiavi e valori | for k, v in pairs(ages) do end |
Funzioni
Annota i parametri e il tipo di ritorno; -> () significa che non restituisce nulla.
| Operazione | Sintassi |
|---|---|
| Parametri tipizzati e ritorno | function add(a: number, b: number): number |
| Non restituisce nulla | function log(msg: string): () end |
| Più valori di ritorno | function split(s: string): (string, string) |
| Parametro opzionale | function greet(name: string?) end |
| Valore predefinito | function greet(name: string?) name = name or "friend" end |
| Variadica | function sum(...: number): number end |
| Funzione anonima | local f = function(x: number): number return x * 2 end |
| Tipo funzione | type Adder = (number, number) -> number |
| Parametro callback | function each(f: (number) -> ()) end |
Alias di tipo, unioni e letterali
Dai un nome a un tipo una volta e riusalo ovunque.
| Operazione | Sintassi |
|---|---|
| Alias di un primitivo | type Health = number |
| Unione | type Id = number | string |
| Opzionale è un'unione con nil | type Maybe = string | nil -- same as string? |
| Tipo letterale (singleton) | type Dir = "up" | "down" |
| Intersezione | type Both = Named & Aged |
| Alias generico | type List<T> = {T} |
| Esportare da un modulo | export type Point = { x: number, y: number } |
| Tipo di un valore esistente | type Config = typeof(config) |
| Chiavi di un tipo tabella | type K = keyof<Point> |
Forme di tabella e metodi
Descrivere oggetti, e il self che arriva con le chiamate con i due punti.
| Operazione | Sintassi |
|---|---|
| Forma inline | local p: { x: number, y: number } = { x = 0, y = 0 } |
| Forma con nome | type Point = { x: number, y: number } |
| Proprietà opzionale | type User = { name: string, age: number? } |
| Forma con indicizzatore | type Bag = { count: number, [string]: any } |
| Estendere una forma | type Admin = User & { level: number } |
| Metodo (scorciatoia con i due punti) | function Point.move(self: Point, dx: number) end |
| Metodo in un tipo | type Point = { move: (self: Point, dx: number) -> () } |
| Schema del costruttore | function Point.new(x: number): Point end |
| Costanti congelate (tipo enum) | local Color = table.freeze({ Red = 1, Blue = 2 }) |
Generics
Una funzione o un tipo che funziona per molti tipi di valore.
| Operazione | Sintassi |
|---|---|
| Funzione generica | function id<T>(x: T): T return x end |
| Due parametri di tipo | function pair<A, B>(a: A, b: B): (A, B) end |
| Generica su un array | function first<T>(xs: {T}): T? return xs[1] end |
| Alias di tipo generico | type Stack<T> = { items: {T} } |
| Istanziare un alias | local s: Stack<string> = { items = {} } |
| Funzione map generica | function map<T, U>(xs: {T}, f: (T) -> U): {U} end |
| Pack generico (variadico) | function call<T...>(f: () -> T...): T... end |
Restringimento, asserzioni e guardie
Convincere il type checker che un valore è ciò che sai che è.
| Operazione | Sintassi |
|---|---|
| Asserzione di tipo (cast) | local n = value :: number |
| Asserzione passando da any | local n = (value :: any) :: number |
| Restringere con typeof | if typeof(x) == "string" then -- x è string end |
| Restringere un opzionale | if name then print(#name) end |
| Return anticipato su nil | if not name then return end |
| Restringere un'unione di letterali | if dir == "up" then end |
| Controllo a runtime ed errore di tipo | assert(typeof(id) == "number", "id must be a number") |
| Asserire che non è nil, poi usarlo | local item = assert(find(id), "missing item") |
Operatori e sintassi che Lua non ha
Le aggiunte che semplificano la vita di tutti i giorni: è qui che il codice Luau smette di sembrare Lua.
| Operazione | Sintassi |
|---|---|
| Sommare e assegnare | hp += 10 |
| Sottrarre / moltiplicare / dividere | hp -= 5, dmg *= 2, dmg /= 2 |
| Divisione intera e assegnazione | n //= 2 |
| Modulo / potenza e assegnazione | n %= 3, n ^= 2 |
| Concatenare e assegnare | msg ..= "!" |
| Divisione intera | local half = 7 // 2 -- 3 |
| Interpolazione di stringhe | Hello, {name}! You have {n} items. (racchiuso tra backtick) |
| Interpolare un'espressione | Total: {price * qty} (racchiuso tra backtick) |
| Continuare un ciclo | for _, v in xs do if v < 0 then continue end end |
| Espressione if-then-else | local label = if hp > 0 then "alive" else "dead" |
| Espressione else-if concatenata | local t = if n > 0 then "pos" elseif n < 0 then "neg" else "zero" |
| Letterali numerici binari / con separatori | 0b1010, 1_000_000 |
Extra della libreria e differenze con Lua
Le funzioni della libreria standard che Luau aggiunge e le funzionalità di Lua che rimuove.
| Elemento | Dettaglio |
|---|---|
| Trovare un valore in un array | table.find(xs, 42) -- indice o nil |
| Copia superficiale | local copy = table.clone(t) |
| Rendere immutabile / verificare | table.freeze(t), table.isfrozen(t) |
| Preallocare un array | table.create(10, 0) |
| Clamp / arrotondamento / segno | math.clamp(x, 0, 1), math.round(x), math.sign(x) |
| Operazioni bit a bit | bit32.band(a, b), bit32.lshift(a, 1) |
| Rimosse per il sandboxing | io, package, loadstring, loadfile, dofile |
| Deprecate ma ancora presenti | getfenv, setfenv (disattivano le ottimizzazioni) |
| Non presenti in Luau | goto / etichette (Luau si basa su Lua 5.1) |
| Leggere stdin su Coddy | io.read() qui funziona: Coddy lo ripristina sopra Luau |
| Estensione dei file | main.luau (funziona anche .lua) |
| Solo Roblox, non Luau di base | game, workspace, Instance.new, task.wait |
Luau è Lua 5.1 più un sistema di tipi graduale: il linguaggio creato da Roblox e reso open source. Questa cheat sheet di Luau copre le parti che *non* sono Lua puro: annotazioni di tipo, tabelle tipizzate, unioni e tipi letterali, generics, asserzioni di tipo e lo zucchero sintattico che Luau aggiunge (+=, interpolazione di stringhe, continue, espressioni if-then-else). Per tutto ciò che i due linguaggi hanno in comune (tabelle, metatabelle, coroutine, libreria string) tieni aperta accanto a questa la cheat sheet di Lua.
Ogni frammento qui è Luau standard, eseguibile con la CLI luau e controllabile nei tipi con luau-analyze. Copia quello che ti serve oppure prova tutto dal vivo nel playground Luau, senza installare nulla. Vuoi imparare il sistema di tipi da zero? Il corso interattivo gratuito di Luau di Coddy lo costruisce lezione dopo lezione.
Domande frequenti sulla cheat sheet di Luau
Questa cheat sheet di Luau è gratuita?
Sì. Questa cheat sheet di Luau è completamente gratuita e non richiede registrazione. Salvala nei preferiti per la prossima volta che ti serve la sintassi di un'unione, di un generic o di una tabella tipizzata.
Luau ha l'operatore +=?
Sì. A differenza di Lua puro, Luau supporta l'assegnazione composta:
+=, -=, *=, /=, //=, %=, ^= e ..= per la concatenazione di stringhe. Quindi hp += 10 è Luau valido (e codice valido per gli script Roblox), mentre in Lua 5.1 devi scrivere hp = hp + 10. Nota che in Luau non esistono ++ né --.Qual è la differenza tra Lua e Luau?
Luau è un superset di Lua 5.1 con un sistema di tipi graduale. Oltre ai tipi aggiunge l'interpolazione di stringhe con i backtick, gli operatori di assegnazione composta,
continue, le espressioni if-then-else, la divisione intera //, l'iterazione generalizzata (for i, v in t do) e funzioni di libreria come table.find, table.clone e table.freeze. Per il sandboxing rimuove loadstring, loadfile, dofile e le librerie io e package, e non ha goto perché si basa sulla 5.1. La maggior parte del codice Lua normale gira senza modifiche come Luau.Come si attiva il controllo dei tipi in Luau?
Metti un commento di modalità sulla prima riga del file:
--!strict controlla tutto e deduce in modo aggressivo, --!nonstrict (il predefinito) controlla solo ciò che hai annotato e --!nocheck disattiva il controllo. Fuori da un editor, esegui luau-analyze main.luau per controllare i tipi senza eseguire e luau main.luau per eseguire.In Luau si scrive interface come in TypeScript?
No, Luau non ha la parola chiave
interface. Le forme degli oggetti si scrivono come tipi tabella e ricevono un nome con type: type User = { name: string, age: number? }. Combina le forme con & invece di extends, e usa export type per renderne una disponibile agli altri moduli.Questa cheat sheet vale anche per lo scripting su Roblox?
Tutto quello che trovi qui è Luau di base, cioè il linguaggio, quindi vale sia per gli script Roblox sia per Luau usato da solo. Quello che *non* c'è è l'API del motore Roblox (
game, workspace, Instance.new, servizi, eventi), che è una libreria sopra il linguaggio ed è documentata da Roblox, non da Luau.Dove posso eseguire questi frammenti Luau?
Nel playground Luau: esegue il vero interprete
luau nel browser, con supporto per stdin, quindi puoi incollare qualsiasi riga di questa pagina e premere Run. Per esercitarti in modo strutturato, il corso interattivo di Luau copre lo stesso materiale con esercizi, progetti e un certificato.Risorse correlate
Altre cheat sheet
