Aide-mémoire Luau
Modes de vérification de types
Un commentaire sur la première ligne du fichier décide de la rigueur de la vérification.
| Mode | Syntaxe |
|---|---|
| Aucune vérification | --!nocheck |
| Par défaut : vérifie ce qui est annoté | --!nonstrict |
| Strict : infère et vérifie tout | --!strict |
| Exécuter un fichier | luau main.luau |
| Vérifier les types sans exécuter | luau-analyze main.luau |
| Désactiver un avertissement du linter | --!nolint UnknownGlobal |
Types de base
Les types primitifs et comment annoter une variable.
| Opération | Syntaxe |
|---|---|
| Nombre | local age: number = 25 |
| Chaîne | local name: string = "Ada" |
| Booléen | local ok: boolean = true |
| Optionnel (peut être nil) | local nick: string? = nil |
| Any (sans vérification) | local x: any = f() |
| Unknown (any plus sûr) | local x: unknown = f() |
| Never (lève toujours une erreur) | function fail(): never error("boom") end |
| Nil | local n: nil = nil |
| Coroutine / buffer | local co: thread, local b: buffer |
| Inféré - aucune annotation | local hp = 100 -- number |
Tables typées : tableaux et maps
Ce sont toujours des tables Lua ; le type dit ce qu'elles contiennent.
| Opération | Syntaxe |
|---|---|
| Tableau de nombres | local xs: {number} = {1, 2, 3} |
| Tableau de chaînes | local names: {string} = {} |
| Map (clés chaînes) | local ages: {[string]: number} = {} |
| Map (tout type de clé) | local seen: {[Player]: boolean} = {} |
| Tableau imbriqué | local grid: {{number}} = {} |
| Tableau de formes | local items: {{id: number}} = {} |
| Tableau en lecture seule | local t = table.freeze({1, 2, 3}) |
| Itérer (généralisé, Luau uniquement) | for i, v in xs do print(i, v) end |
| Itérer clés et valeurs | for k, v in pairs(ages) do end |
Fonctions
Annotez les paramètres et le type de retour ; -> () signifie aucun retour.
| Opération | Syntaxe |
|---|---|
| Paramètres et retour typés | function add(a: number, b: number): number |
| Ne retourne rien | function log(msg: string): () end |
| Retours multiples | function split(s: string): (string, string) |
| Paramètre optionnel | function greet(name: string?) end |
| Valeur par défaut | function greet(name: string?) name = name or "friend" end |
| Variadique | function sum(...: number): number end |
| Fonction anonyme | local f = function(x: number): number return x * 2 end |
| Type de fonction | type Adder = (number, number) -> number |
| Paramètre de callback | function each(f: (number) -> ()) end |
Alias de type, unions et littéraux
Nommez un type une fois, réutilisez-le partout.
| Opération | Syntaxe |
|---|---|
| Alias d'un primitif | type Health = number |
| Union | type Id = number | string |
| Optionnel = union avec nil | type Maybe = string | nil -- same as string? |
| Type littéral (singleton) | type Dir = "up" | "down" |
| Intersection | type Both = Named & Aged |
| Alias générique | type List<T> = {T} |
| Exporter depuis un module | export type Point = { x: number, y: number } |
| Type d'une valeur existante | type Config = typeof(config) |
| Clés d'un type de table | type K = keyof<Point> |
Formes de table et méthodes
Décrire des objets, et le self qui vient avec les appels à deux-points.
| Opération | Syntaxe |
|---|---|
| Forme en ligne | local p: { x: number, y: number } = { x = 0, y = 0 } |
| Forme nommée | type Point = { x: number, y: number } |
| Propriété optionnelle | type User = { name: string, age: number? } |
| Forme + indexeur | type Bag = { count: number, [string]: any } |
| Étendre une forme | type Admin = User & { level: number } |
| Méthode (raccourci deux-points) | function Point.move(self: Point, dx: number) end |
| Méthode dans un type | type Point = { move: (self: Point, dx: number) -> () } |
| Motif de constructeur | function Point.new(x: number): Point end |
| Constantes gelées (façon enum) | local Color = table.freeze({ Red = 1, Blue = 2 }) |
Génériques
Une fonction ou un type qui marche pour de nombreux types de valeurs.
| Opération | Syntaxe |
|---|---|
| Fonction générique | function id<T>(x: T): T return x end |
| Deux paramètres de type | function pair<A, B>(a: A, b: B): (A, B) end |
| Générique sur un tableau | function first<T>(xs: {T}): T? return xs[1] end |
| Alias de type générique | type Stack<T> = { items: {T} } |
| Instancier un alias | local s: Stack<string> = { items = {} } |
| Fonction map générique | function map<T, U>(xs: {T}, f: (T) -> U): {U} end |
| Pack générique (variadique) | function call<T...>(f: () -> T...): T... end |
Réduction, assertions et gardes
Convaincre le vérificateur qu'une valeur est bien ce que vous savez.
| Opération | Syntaxe |
|---|---|
| Assertion de type (cast) | local n = value :: number |
| Assertion via any | local n = (value :: any) :: number |
| Réduire avec typeof | if typeof(x) == "string" then -- x is string end |
| Réduire un optionnel | if name then print(#name) end |
| Retour anticipé si nil | if not name then return end |
| Réduire une union littérale | if dir == "up" then end |
| Vérification à l'exécution | assert(typeof(id) == "number", "id must be a number") |
| Affirmer non-nil, puis utiliser | local item = assert(find(id), "missing item") |
Opérateurs et syntaxe absents de Lua
Les commodités du quotidien - c'est là que le code Luau cesse de ressembler à du Lua.
| Opération | Syntaxe |
|---|---|
| Ajouter et affecter | hp += 10 |
| Soustraire / multiplier / diviser | hp -= 5, dmg *= 2, dmg /= 2 |
| Division entière et affectation | n //= 2 |
| Modulo / puissance et affectation | n %= 3, n ^= 2 |
| Concaténer et affecter | msg ..= "!" |
| Division entière | local half = 7 // 2 -- 3 |
| Interpolation de chaînes | Hello, {name}! You have {n} items. (entourer d'accents graves) |
| Interpoler une expression | Total: {price * qty} (entourer d'accents graves) |
| Continuer une boucle | for _, v in xs do if v < 0 then continue end end |
| Expression if-then-else | local label = if hp > 0 then "alive" else "dead" |
| Expression else-if enchaînée | local t = if n > 0 then "pos" elseif n < 0 then "neg" else "zero" |
| Littéraux binaires / avec séparateur | 0b1010, 1_000_000 |
Extras de bibliothèque et différences avec Lua
Les fonctions que Luau ajoute à la bibliothèque standard, et ce qu'il retire de Lua.
| Élément | Détail |
|---|---|
| Trouver une valeur dans un tableau | table.find(xs, 42) -- index ou nil |
| Copie superficielle | local copy = table.clone(t) |
| Rendre immuable / vérifier | table.freeze(t), table.isfrozen(t) |
| Préallouer un tableau | table.create(10, 0) |
| Clamp / round / sign | math.clamp(x, 0, 1), math.round(x), math.sign(x) |
| Opérations bit à bit | bit32.band(a, b), bit32.lshift(a, 1) |
| Retiré pour l'isolation | io, package, loadstring, loadfile, dofile |
| Déprécié mais présent | getfenv, setfenv (ils désactivent les optimisations) |
| Absent de Luau | goto / étiquettes (Luau repose sur Lua 5.1) |
| Lire stdin sur Coddy | io.read() fonctionne ici - Coddy le restaure au-dessus de Luau |
| Extension de fichier | main.luau (.lua fonctionne aussi) |
| Roblox uniquement, pas Luau de base | game, workspace, Instance.new, task.wait |
Luau, c'est Lua 5.1 plus un système de types graduel - le langage créé et ouvert par Roblox. Cet aide-mémoire couvre ce qui n'est *pas* du Lua ordinaire : annotations de type, tables typées, unions et types littéraux, génériques, assertions de type, et le sucre syntaxique que Luau ajoute (+=, interpolation de chaînes, continue, expressions if-then-else). Pour tout ce que les deux langages partagent - tables, métatables, coroutines, bibliothèque de chaînes - gardez l'aide-mémoire Lua à côté.
Tout ici est du Luau standard, exécutable avec la CLI luau et vérifiable avec luau-analyze. Copiez ce dont vous avez besoin, ou essayez-le en direct dans le playground Luau - rien à installer. Vous découvrez le système de types ? Le cours Luau interactif gratuit de Coddy le construit leçon par leçon.
FAQ de l'aide-mémoire Luau
Cet aide-mémoire Luau est-il gratuit ?
Oui. Cet aide-mémoire Luau est entièrement gratuit et sans inscription. Mettez-le en favori pour la prochaine fois que vous chercherez la syntaxe d'une union, d'un générique ou d'une table typée.
Luau a-t-il un opérateur += ?
Oui. Contrairement à Lua, Luau accepte l'affectation composée :
+=, -=, *=, /=, //=, %=, ^= et ..= pour la concaténation. Donc hp += 10 est du Luau valide (et du code Roblox valide), alors qu'en Lua 5.1 il faut écrire hp = hp + 10. À noter : ni ++ ni -- n'existent en Luau.Quelle est la différence entre Lua et Luau ?
Luau est un surensemble de Lua 5.1 doté d'un système de types graduel. En plus des types, il ajoute l'interpolation de chaînes avec des accents graves, les opérateurs d'affectation composée,
continue, les expressions if-then-else, la division entière //, l'itération généralisée (for i, v in t do) et des fonctions comme table.find, table.clone et table.freeze. Pour l'isolation, il retire loadstring, loadfile, dofile et les bibliothèques io et package, et il n'a pas de goto puisqu'il repose sur 5.1. La plupart du code Lua ordinaire s'exécute tel quel en Luau.Comment activer la vérification de types en Luau ?
Placez un commentaire de mode sur la première ligne du fichier :
--!strict vérifie tout et infère agressivement, --!nonstrict (le défaut) ne vérifie que ce que vous avez annoté, et --!nocheck désactive la vérification. Hors éditeur, lancez luau-analyze main.luau pour vérifier sans exécuter, et luau main.luau pour exécuter.Écrit-on interface en Luau comme en TypeScript ?
Non - Luau n'a pas de mot-clé
interface. Les formes d'objet s'écrivent comme des types de table et se nomment avec type : type User = { name: string, age: number? }. Combinez les formes avec & au lieu de extends, et utilisez export type pour les rendre disponibles à d'autres modules.Cet aide-mémoire équivaut-il au scripting Roblox ?
Tout ici est du Luau de base - le langage - donc valable aussi bien pour les scripts Roblox que pour Luau autonome. Ce qui n'y figure *pas*, c'est l'API du moteur Roblox (
game, workspace, Instance.new, services, événements), une bibliothèque posée sur le langage et documentée par Roblox, pas par Luau.Où exécuter ces extraits Luau ?
Dans le playground Luau : il exécute le véritable interpréteur
luau dans votre navigateur, avec prise en charge de stdin, donc vous pouvez coller n'importe quelle ligne de cette page et appuyer sur Exécuter. Pour une pratique structurée, le cours Luau interactif couvre le même contenu avec exercices, projets et certificat.Ressources connexes
Plus d'aide-mémoires
