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.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
