Luau Cheat Sheet: ściąga z Luau
Tryby sprawdzania typów
Komentarz w pierwszej linii pliku decyduje, jak ściśle Luau go sprawdza.
| Tryb | Składnia |
|---|---|
| Bez sprawdzania typów | --!nocheck |
| Domyślny: sprawdza to, co ma adnotacje | --!nonstrict |
| Ścisły: wnioskuje i sprawdza wszystko | --!strict |
| Uruchomienie pliku | luau main.luau |
| Sprawdzenie typów bez uruchamiania | luau-analyze main.luau |
| Wyłączenie jednego ostrzeżenia lintera | --!nolint UnknownGlobal |
Podstawowe typy
Typy proste i sposób dodawania adnotacji do zmiennej.
| Operacja | Składnia |
|---|---|
| Liczba | local age: number = 25 |
| Łańcuch | local name: string = "Ada" |
| Wartość logiczna | local ok: boolean = true |
| Opcjonalny (może być nil) | local nick: string? = nil |
| Any (wyłączenie sprawdzania) | local x: any = f() |
| Unknown (bezpieczniejszy any) | local x: unknown = f() |
| Never (zawsze rzuca błąd) | function fail(): never error("boom") end |
| Nil | local n: nil = nil |
| Korutyna / bufor | local co: thread, local b: buffer |
| Wnioskowany: adnotacja niepotrzebna | local hp = 100 -- number |
Typowane tabele: tablice i mapy
Tabele to nadal tabele Lua: typ mówi, co jest w środku.
| Operacja | Składnia |
|---|---|
| Tablica liczb | local xs: {number} = {1, 2, 3} |
| Tablica łańcuchów | local names: {string} = {} |
| Mapa (klucze tekstowe) | local ages: {[string]: number} = {} |
| Mapa (dowolny typ klucza) | local seen: {[Player]: boolean} = {} |
| Tablica zagnieżdżona | local grid: {{number}} = {} |
| Tablica obiektów o danym kształcie | local items: {{id: number}} = {} |
| Tablica tylko do odczytu | local t = table.freeze({1, 2, 3}) |
| Iteracja (uogólniona, tylko Luau) | for i, v in xs do print(i, v) end |
| Iteracja po kluczach i wartościach | for k, v in pairs(ages) do end |
Funkcje
Dodaj adnotacje do parametrów i typu zwracanego; -> () oznacza, że funkcja nic nie zwraca.
| Operacja | Składnia |
|---|---|
| Typowane parametry i wynik | function add(a: number, b: number): number |
| Nic nie zwraca | function log(msg: string): () end |
| Wiele wartości zwracanych | function split(s: string): (string, string) |
| Parametr opcjonalny | function greet(name: string?) end |
| Wartość domyślna | function greet(name: string?) name = name or "friend" end |
| Zmienna liczba argumentów | function sum(...: number): number end |
| Funkcja anonimowa | local f = function(x: number): number return x * 2 end |
| Typ funkcji | type Adder = (number, number) -> number |
| Parametr callback | function each(f: (number) -> ()) end |
Aliasy typów, unie i literały
Nazwij typ raz i używaj go wszędzie.
| Operacja | Składnia |
|---|---|
| Alias typu prostego | type Health = number |
| Unia | type Id = number | string |
| Opcjonalny to unia z nil | type Maybe = string | nil -- same as string? |
| Typ literałowy (singleton) | type Dir = "up" | "down" |
| Przecięcie | type Both = Named & Aged |
| Alias generyczny | type List<T> = {T} |
| Eksport z modułu | export type Point = { x: number, y: number } |
| Typ istniejącej wartości | type Config = typeof(config) |
| Klucze typu tabeli | type K = keyof<Point> |
Kształty tabel i metody
Opisywanie obiektów i self, które pojawia się przy wywołaniach z dwukropkiem.
| Operacja | Składnia |
|---|---|
| Kształt w linii | local p: { x: number, y: number } = { x = 0, y = 0 } |
| Nazwany kształt | type Point = { x: number, y: number } |
| Właściwość opcjonalna | type User = { name: string, age: number? } |
| Kształt z indeksatorem | type Bag = { count: number, [string]: any } |
| Rozszerzenie kształtu | type Admin = User & { level: number } |
| Metoda (skrót z dwukropkiem) | function Point.move(self: Point, dx: number) end |
| Metoda w typie | type Point = { move: (self: Point, dx: number) -> () } |
| Wzorzec konstruktora | function Point.new(x: number): Point end |
| Zamrożone stałe (jak enum) | local Color = table.freeze({ Red = 1, Blue = 2 }) |
Generyki
Jedna funkcja lub typ, które działają z wieloma typami wartości.
| Operacja | Składnia |
|---|---|
| Funkcja generyczna | function id<T>(x: T): T return x end |
| Dwa parametry typu | function pair<A, B>(a: A, b: B): (A, B) end |
| Funkcja generyczna dla tablicy | function first<T>(xs: {T}): T? return xs[1] end |
| Generyczny alias typu | type Stack<T> = { items: {T} } |
| Konkretyzacja aliasu | local s: Stack<string> = { items = {} } |
| Generyczna funkcja map | function map<T, U>(xs: {T}, f: (T) -> U): {U} end |
| Generyczny pakiet (zmienna liczba) | function call<T...>(f: () -> T...): T... end |
Zawężanie, asercje i strażnicy
Przekonywanie systemu typów, że wartość jest tym, czym wiesz, że jest.
| Operacja | Składnia |
|---|---|
| Asercja typu (rzutowanie) | local n = value :: number |
| Asercja przez any | local n = (value :: any) :: number |
| Zawężenie przez typeof | if typeof(x) == "string" then -- x to string end |
| Zawężenie typu opcjonalnego | if name then print(#name) end |
| Wczesny powrót przy nil | if not name then return end |
| Zawężenie unii literałów | if dir == "up" then end |
| Sprawdzenie w czasie działania i błąd typu | assert(typeof(id) == "number", "id must be a number") |
| Asercja, że nie nil, a potem użycie | local item = assert(find(id), "missing item") |
Operatory i składnia, których nie ma w Lua
Codzienne ułatwienia: to tutaj kod Luau przestaje wyglądać jak Lua.
| Operacja | Składnia |
|---|---|
| Dodanie i przypisanie | hp += 10 |
| Odejmowanie / mnożenie / dzielenie | hp -= 5, dmg *= 2, dmg /= 2 |
| Dzielenie całkowite i przypisanie | n //= 2 |
| Modulo / potęga i przypisanie | n %= 3, n ^= 2 |
| Łączenie i przypisanie | msg ..= "!" |
| Dzielenie całkowite | local half = 7 // 2 -- 3 |
| Interpolacja łańcuchów | Hello, {name}! You have {n} items. (w odwrotnych apostrofach) |
| Interpolacja wyrażenia | Total: {price * qty} (w odwrotnych apostrofach) |
| Continue w pętli | for _, v in xs do if v < 0 then continue end end |
| Wyrażenie if-then-else | local label = if hp > 0 then "alive" else "dead" |
| Łańcuchowe wyrażenie else-if | local t = if n > 0 then "pos" elseif n < 0 then "neg" else "zero" |
| Literały binarne / z separatorami | 0b1010, 1_000_000 |
Dodatki w bibliotekach i różnice względem Lua
Funkcje biblioteki standardowej dodane w Luau i funkcje Lua, które zostały usunięte.
| Element | Szczegóły |
|---|---|
| Wyszukanie wartości w tablicy | table.find(xs, 42) -- indeks lub nil |
| Płytka kopia | local copy = table.clone(t) |
| Zamrożenie / sprawdzenie | table.freeze(t), table.isfrozen(t) |
| Prealokacja tablicy | table.create(10, 0) |
| Ograniczenie / zaokrąglenie / znak | math.clamp(x, 0, 1), math.round(x), math.sign(x) |
| Operacje bitowe | bit32.band(a, b), bit32.lshift(a, 1) |
| Usunięte ze względu na sandboxing | io, package, loadstring, loadfile, dofile |
| Przestarzałe, ale wciąż dostępne | getfenv, setfenv (wyłączają optymalizacje) |
| Brak w Luau | goto / etykiety (Luau bazuje na Lua 5.1) |
| Odczyt stdin w Coddy | io.read() działa tutaj: Coddy przywraca je na bazie Luau |
| Rozszerzenie pliku | main.luau (.lua też działa) |
| Tylko Roblox, nie rdzeń Luau | game, workspace, Instance.new, task.wait |
Luau to Lua 5.1 z dodanym stopniowym systemem typów: język stworzony przez Roblox i udostępniony jako open source. Ten Luau cheat sheet obejmuje to, czego *nie ma* w zwykłej Lua: adnotacje typów, typowane tabele, unie i typy literałowe, generyki, asercje typów oraz lukier składniowy, który dodaje Luau (+=, interpolacja łańcuchów, continue, wyrażenia if-then-else). Do wszystkiego, co oba języki mają wspólne (tabele, metatabele, korutyny, biblioteka string), trzymaj obok otwartą ściągę z Lua.
Każdy fragment tutaj to standardowe Luau, które uruchomisz przez CLI luau i sprawdzisz pod kątem typów przez luau-analyze. Skopiuj to, czego potrzebujesz, albo wypróbuj dowolny fragment w edytorze online Luau, bez instalacji. Uczysz się systemu typów od zera? Darmowy interaktywny kurs Luau w Coddy buduje go lekcja po lekcji.
Luau cheat sheet: najczęstsze pytania
Czy ten Luau cheat sheet jest darmowy?
Tak. Ta ściąga z Luau jest całkowicie darmowa i nie wymaga rejestracji. Dodaj ją do zakładek na następny raz, gdy potrzebujesz składni unii, generyka albo typowanej tabeli.
Czy Luau ma operator +=?
Tak. W przeciwieństwie do zwykłej Lua, Luau obsługuje przypisanie złożone:
+=, -=, *=, /=, //=, %=, ^= oraz ..= do łączenia łańcuchów. Zatem hp += 10 to poprawne Luau (i poprawny kod skryptu Roblox), a w Lua 5.1 trzeba napisać hp = hp + 10. Pamiętaj, że w Luau nie ma ++ ani --.Czym różni się Lua od Luau?
Luau to nadzbiór Lua 5.1 ze stopniowym systemem typów. Oprócz typów dodaje interpolację łańcuchów w odwrotnych apostrofach, operatory przypisania złożonego,
continue, wyrażenia if-then-else, dzielenie całkowite //, uogólnioną iterację (for i, v in t do) oraz funkcje biblioteczne, takie jak table.find, table.clone i table.freeze. Ze względu na sandboxing usuwa loadstring, loadfile, dofile oraz biblioteki io i package, a goto nie ma, bo bazuje na 5.1. Większość zwykłego kodu Lua działa w Luau bez zmian.Jak włączyć sprawdzanie typów w Luau?
Umieść komentarz z trybem w pierwszej linii pliku:
--!strict sprawdza wszystko i agresywnie wnioskuje typy, --!nonstrict (domyślny) sprawdza tylko to, co ma adnotacje, a --!nocheck wyłącza sprawdzanie. Poza edytorem uruchom luau-analyze main.luau, aby sprawdzić typy bez wykonywania, i luau main.luau, aby uruchomić.Czy w Luau piszę interface jak w TypeScripcie?
Nie. Luau nie ma słowa kluczowego
interface. Kształty obiektów zapisuje się jako typy tabel i nadaje im nazwę przez type: type User = { name: string, age: number? }. Kształty łączysz przez & zamiast extends, a export type udostępnia typ innym modułom.Czy ta ściąga to to samo co skryptowanie w Roblox?
Wszystko tutaj to rdzeń Luau, czyli sam język, więc dotyczy zarówno skryptów Roblox, jak i samodzielnego Luau. *Nie ma* tu API silnika Roblox (
game, workspace, Instance.new, usługi, zdarzenia), które jest biblioteką nadbudowaną na języku i dokumentuje je Roblox, a nie Luau.Gdzie mogę uruchomić te fragmenty Luau?
W edytorze online Luau: uruchamia on prawdziwy interpreter
luau w przeglądarce z obsługą stdin, więc możesz wkleić dowolny wiersz z tej strony i nacisnąć Run. Do systematycznej nauki służy interaktywny kurs Luau z tym samym materiałem, ćwiczeniami, projektami i certyfikatem.Powiązane materiały
Więcej ściąg
