Guia rápido de Luau
Modos de verificação de tipos
Um comentário na primeira linha do arquivo define o rigor da verificação.
| Modo | Sintaxe |
|---|---|
| Sem verificação de tipos | --!nocheck |
| Padrão: verifica o que foi anotado | --!nonstrict |
| Estrito: infere e verifica tudo | --!strict |
| Executar um arquivo | luau main.luau |
| Verificar tipos sem executar | luau-analyze main.luau |
| Desligar um aviso do linter | --!nolint UnknownGlobal |
Tipos básicos
Os tipos primitivos e como anotar uma variável.
| Operação | Sintaxe |
|---|---|
| Número | local age: number = 25 |
| String | local name: string = "Ada" |
| Booleano | local ok: boolean = true |
| Opcional (pode ser nil) | local nick: string? = nil |
| Any (sem verificação) | local x: any = f() |
| Unknown (any mais seguro) | local x: unknown = f() |
| Never (sempre lança erro) | function fail(): never error("boom") end |
| Nil | local n: nil = nil |
| Corrotina / buffer | local co: thread, local b: buffer |
| Inferido: sem anotação | local hp = 100 -- number |
Tabelas tipadas: arrays e mapas
Continuam sendo tabelas Lua; o tipo diz o que há dentro.
| Operação | Sintaxe |
|---|---|
| Array de números | local xs: {number} = {1, 2, 3} |
| Array de strings | local names: {string} = {} |
| Mapa (chaves string) | local ages: {[string]: number} = {} |
| Mapa (qualquer tipo de chave) | local seen: {[Player]: boolean} = {} |
| Array aninhado | local grid: {{number}} = {} |
| Array de formatos | local items: {{id: number}} = {} |
| Array somente leitura | local t = table.freeze({1, 2, 3}) |
| Iterar (generalizado, só Luau) | for i, v in xs do print(i, v) end |
| Iterar chaves e valores | for k, v in pairs(ages) do end |
Funções
Anote parâmetros e o tipo de retorno; -> () significa que não retorna nada.
| Operação | Sintaxe |
|---|---|
| Parâmetros e retorno tipados | function add(a: number, b: number): number |
| Não retorna nada | function log(msg: string): () end |
| Retornos múltiplos | function split(s: string): (string, string) |
| Parâmetro opcional | function greet(name: string?) end |
| Valor padrão | function greet(name: string?) name = name or "friend" end |
| Variádica | function sum(...: number): number end |
| Função anônima | local f = function(x: number): number return x * 2 end |
| Tipo de função | type Adder = (number, number) -> number |
| Parâmetro de callback | function each(f: (number) -> ()) end |
Aliases de tipo, uniões e literais
Nomeie um tipo uma vez e reutilize em todo lugar.
| Operação | Sintaxe |
|---|---|
| Alias de um primitivo | type Health = number |
| União | type Id = number | string |
| Opcional = união com nil | type Maybe = string | nil -- same as string? |
| Tipo literal (singleton) | type Dir = "up" | "down" |
| Interseção | type Both = Named & Aged |
| Alias genérico | type List<T> = {T} |
| Exportar de um módulo | export type Point = { x: number, y: number } |
| Tipo de um valor existente | type Config = typeof(config) |
| Chaves de um tipo de tabela | type K = keyof<Point> |
Formatos de tabela e métodos
Descrevendo objetos, e o self que vem com as chamadas com dois-pontos.
| Operação | Sintaxe |
|---|---|
| Formato inline | local p: { x: number, y: number } = { x = 0, y = 0 } |
| Formato nomeado | type Point = { x: number, y: number } |
| Propriedade opcional | type User = { name: string, age: number? } |
| Formato + indexador | type Bag = { count: number, [string]: any } |
| Estender um formato | type Admin = User & { level: number } |
| Método (atalho com dois-pontos) | function Point.move(self: Point, dx: number) end |
| Método em um tipo | type Point = { move: (self: Point, dx: number) -> () } |
| Padrão de construtor | function Point.new(x: number): Point end |
| Constantes congeladas (tipo enum) | local Color = table.freeze({ Red = 1, Blue = 2 }) |
Genéricos
Uma função ou tipo que serve para muitos tipos de valor.
| Operação | Sintaxe |
|---|---|
| Função genérica | function id<T>(x: T): T return x end |
| Dois parâmetros de tipo | function pair<A, B>(a: A, b: B): (A, B) end |
| Genérica sobre um array | function first<T>(xs: {T}): T? return xs[1] end |
| Alias de tipo genérico | type Stack<T> = { items: {T} } |
| Instanciar um alias | local s: Stack<string> = { items = {} } |
| Função map genérica | function map<T, U>(xs: {T}, f: (T) -> U): {U} end |
| Pacote genérico (variádico) | function call<T...>(f: () -> T...): T... end |
Estreitamento, asserções e guards
Convencer o verificador de que um valor é o que você já sabe.
| Operação | Sintaxe |
|---|---|
| Asserção de tipo (cast) | local n = value :: number |
| Asserção passando por any | local n = (value :: any) :: number |
| Estreitar com typeof | if typeof(x) == "string" then -- x é string end |
| Estreitar um opcional | if name then print(#name) end |
| Retorno antecipado se for nil | if not name then return end |
| Estreitar uma união literal | if dir == "up" then end |
| Checagem em tempo de execução | assert(typeof(id) == "number", "id must be a number") |
| Garantir que não é nil e usar | local item = assert(find(id), "missing item") |
Operadores e sintaxe que o Lua não tem
As melhorias do dia a dia - é aqui que o código Luau para de parecer Lua.
| Operação | Sintaxe |
|---|---|
| Somar e atribuir | hp += 10 |
| Subtrair / multiplicar / dividir | hp -= 5, dmg *= 2, dmg /= 2 |
| Divisão inteira e atribuição | n //= 2 |
| Módulo / potência e atribuição | n %= 3, n ^= 2 |
| Concatenar e atribuir | msg ..= "!" |
| Divisão inteira | local half = 7 // 2 -- 3 |
| Interpolação de strings | Hello, {name}! You have {n} items. (entre acentos graves) |
| Interpolar uma expressão | Total: {price * qty} (entre acentos graves) |
| Continuar um laço | for _, v in xs do if v < 0 then continue end end |
| Expressão if-then-else | local label = if hp > 0 then "alive" else "dead" |
| Expressão com else-if em cadeia | local t = if n > 0 then "pos" elseif n < 0 then "neg" else "zero" |
| Literais binários / com separador | 0b1010, 1_000_000 |
Extras da biblioteca e diferenças do Lua
Funções que o Luau adiciona à biblioteca padrão e recursos do Lua que ele remove.
| Item | Detalhe |
|---|---|
| Encontrar um valor em um array | table.find(xs, 42) -- índice ou nil |
| Cópia rasa | local copy = table.clone(t) |
| Tornar imutável / verificar | table.freeze(t), table.isfrozen(t) |
| Prealocar um array | table.create(10, 0) |
| Clamp / round / sign | math.clamp(x, 0, 1), math.round(x), math.sign(x) |
| Operações de bits | bit32.band(a, b), bit32.lshift(a, 1) |
| Removido por isolamento | io, package, loadstring, loadfile, dofile |
| Obsoleto mas ainda presente | getfenv, setfenv (desativam otimizações) |
| Não existe no Luau | goto / rótulos (o Luau se baseia no Lua 5.1) |
| Ler stdin na Coddy | io.read() funciona aqui: a Coddy o restaura sobre o Luau |
| Extensão de arquivo | main.luau (.lua também funciona) |
| Só no Roblox, não no Luau base | game, workspace, Instance.new, task.wait |
Luau é o Lua 5.1 mais um sistema de tipos gradual - a linguagem que a Roblox criou e abriu o código. Este guia cobre o que *não* é Lua puro: anotações de tipo, tabelas tipadas, uniões e tipos literais, genéricos, asserções de tipo e o açúcar sintático que o Luau adiciona (+=, interpolação de strings, continue, expressões if-then-else). Para tudo o que as duas linguagens têm em comum - tabelas, metatabelas, corrotinas, a biblioteca de strings - mantenha o guia rápido de Lua ao lado.
Tudo aqui é Luau padrão, executável com a CLI luau e verificável com luau-analyze. Copie o que precisar ou teste ao vivo no playground de Luau - sem instalar nada. Começando no sistema de tipos? O curso interativo gratuito de Luau da Coddy constrói tudo lição por lição.
FAQ do guia rápido de Luau
Este guia rápido de Luau é grátis?
Sim. Este guia rápido de Luau é totalmente gratuito e não exige cadastro. Salve nos favoritos para a próxima vez que precisar da sintaxe de uma união, de um genérico ou de uma tabela tipada.
O Luau tem o operador +=?
Sim. Diferente do Lua puro, o Luau tem atribuição composta:
+=, -=, *=, /=, //=, %=, ^= e ..= para concatenar strings. Então hp += 10 é Luau válido (e código válido do Roblox), enquanto no Lua 5.1 você precisa escrever hp = hp + 10. Atenção: não existem ++ nem -- no Luau.Qual é a diferença entre Lua e Luau?
Luau é um superconjunto do Lua 5.1 com um sistema de tipos gradual. Além dos tipos, ele adiciona interpolação de strings com acentos graves, operadores de atribuição composta,
continue, expressões if-then-else, divisão inteira //, iteração generalizada (for i, v in t do) e funções como table.find, table.clone e table.freeze. Por isolamento, remove loadstring, loadfile, dofile e as bibliotecas io e package, e não tem goto porque se baseia no 5.1. A maior parte do código Lua comum roda sem alterações como Luau.Como ligo a verificação de tipos no Luau?
Coloque um comentário de modo na primeira linha do arquivo:
--!strict verifica tudo e infere agressivamente, --!nonstrict (o padrão) só verifica o que você anotou e --!nocheck desliga a verificação. Fora do editor, rode luau-analyze main.luau para verificar tipos sem executar e luau main.luau para executar.Escrevo interface no Luau como no TypeScript?
Não - o Luau não tem a palavra-chave
interface. Formatos de objeto são escritos como tipos de tabela e nomeados com type: type User = { name: string, age: number? }. Combine formatos com & em vez de extends e use export type para disponibilizá-los a outros módulos.Este guia é a mesma coisa que scripting no Roblox?
Tudo aqui é Luau base (a linguagem), então vale igual para scripts do Roblox e para Luau independente. O que *não* está aqui é a API do motor do Roblox (
game, workspace, Instance.new, serviços, eventos), que é uma biblioteca sobre a linguagem e é documentada pela Roblox, não pelo Luau. O curso Roblox Game Scripting ensina essa API com scripts que rodam em um pequeno jogo no estilo Roblox no seu navegador.Onde posso rodar estes trechos de Luau?
No playground de Luau - ele roda o interpretador
luau real no navegador, com suporte a stdin, então você pode colar qualquer linha desta página e clicar em Executar. Para prática estruturada, o curso interativo de Luau cobre o mesmo material com exercícios, projetos e certificado.Recursos relacionados
Mais folhas de consulta
