Folha de Consulta Lua
Última atualização
Hello World e executar código
Lua é minimalista - uma única instrução já roda.
| Operação | Sintaxe |
|---|---|
| Exibir uma linha | print("Hello, World!") |
| Exibir vários valores | print("x", 1, true) |
| Escrever sem quebra de linha | io.write("Hi") |
| Comentário | -- this is a comment |
| Comentário de várias linhas | --[[ ... ]] |
| Concatenar strings | print("Hi " .. name) |
| Executar um arquivo | lua app.lua |
| Shell interativo | lua |
Variáveis e tipos
Variáveis são globais por padrão; declare locais com local.
| Operação | Sintaxe |
|---|---|
| Variável local | local age = 30 |
| Variável global | count = 0 |
| Atribuição múltipla | local a, b = 1, 2 |
| Os oito tipos | nil, boolean, number, string, table, function, userdata, thread |
| Nil / booleanos | nil, true, false |
| Verificar tipo | type(x) retorna "number" |
| Converter para número | tonumber("42") |
| Converter para string | tostring(42) |
Strings
Strings são imutáveis; tanto aspas simples quanto duplas funcionam.
| Operação | Sintaxe |
|---|---|
| Comprimento | #s ou string.len(s) |
| Concatenar | s1 .. s2 |
| Maiúsculas / minúsculas | s:upper(), s:lower() |
| Substring | s:sub(1, 3) |
| Encontrar substring | s:find("ell") |
| Substituir (gsub) | s:gsub("a", "b") |
| Formatar | string.format("%05d", 42) |
| String longa | [[ multi\nline ]] |
Tabelas (a estrutura de dados central)
As tabelas são o único tipo estruturado de Lua - funcionam como arrays, maps e objetos.
| Operação | Sintaxe |
|---|---|
| Tabela vazia | local t = {} |
| Estilo array (base 1) | local t = {10, 20, 30} |
| Acessar elemento do array | t[1] (primeiro elemento) |
| Tabela estilo map | local u = {name = "Ada", age = 30} |
| Acessar valor do map | u.name ou u["name"] |
| Definir um valor | t[4] = 40, u.email = "a@x.com" |
| Comprimento da parte array | #t |
| Iterar array (ipairs) | for i, v in ipairs(t) do ... end |
| Iterar todas as chaves (pairs) | for k, v in pairs(u) do ... end |
| Tabela aninhada | local m = {a = {1, 2}} |
Controle de fluxo
Os blocos fecham com end; apenas nil e false são falsy.
| Operação | Sintaxe |
|---|---|
| If / elseif / else | if x > 0 then ... elseif x < 0 then ... else ... end |
| Operadores lógicos | and, or, not |
| For numérico | for i = 1, 10 do ... end |
| For com passo | for i = 10, 1, -1 do ... end |
| Laço while | while x < 100 do ... end |
| Repeat-until | repeat ... until done |
| Break | break |
| Operador de diferença | if a ~= b then ... end |
Funções
Funções são valores de primeira classe e podem retornar múltiplos resultados.
| Operação | Sintaxe |
|---|---|
| Definir uma função | function add(a, b) return a + b end |
| Função local | local function square(x) return x * x end |
| Função anônima | local f = function(x) return x * 2 end |
| Múltiplos valores de retorno | function bounds() return 1, 10 end |
| Capturar múltiplos retornos | local lo, hi = bounds() |
| Função variádica | function sum(...) ... end |
| Coletar varargs | local args = {...} |
| Método (sintaxe com dois-pontos) | function obj:greet() ... end |
Biblioteca de string
Funções comuns da biblioteca de string (chamáveis como s:fn()).
| Função | O que faz |
|---|---|
string.len(s) | Comprimento da string |
string.sub(s, i, j) | Substring do índice i ao j |
string.upper(s) | Cópia em maiúsculas |
string.rep(s, n) | Repete a string n vezes |
string.find(s, p) | Encontra um padrão, retorna início/fim |
string.match(s, p) | Retorna a primeira correspondência do padrão |
string.gsub(s, p, r) | Substitui todas as correspondências do padrão |
string.format(fmt, ...) | Formata valores em uma string |
Bibliotecas table e math
Auxiliares para trabalhar com tabelas estilo array e com números.
| Função | O que faz |
|---|---|
table.insert(t, v) | Adiciona um valor ao final |
table.insert(t, i, v) | Insere v na posição i |
table.remove(t, i) | Remove e retorna o elemento em i |
table.concat(t, ", ") | Junta os elementos em uma string |
table.sort(t) | Ordena o array no lugar |
math.floor(x) / math.ceil(x) | Arredonda para baixo / para cima |
math.max(...) / math.min(...) | Maior / menor argumento |
math.random(1, 6) | Inteiro aleatório em um intervalo |
Metatables (resumo)
As metatables permitem personalizar como as tabelas se comportam - operadores, indexação e mais.
| Operação | Sintaxe |
|---|---|
| Definir uma metatable | setmetatable(t, mt) |
| Obter uma metatable | getmetatable(t) |
| Fallback para chaves ausentes | mt.__index = defaults |
| Padrão via função | mt.__index = function(t, k) ... end |
| Personalizar adição | mt.__add = function(a, b) ... end |
| Personalizar tostring | mt.__tostring = function(t) ... end |
| OOP baseada em protótipos | mt.__index = ClassTable |
A sintaxe de Lua que você mais usa, em uma única página. Esta folha de consulta Lua é uma referência rápida para o núcleo da linguagem - variáveis e tipos, strings, controle de fluxo, funções e as tabelas que servem como a única e flexível estrutura de dados de Lua, além de um vislumbre das bibliotecas padrão e das metatables.
Tudo aqui é Lua padrão e roda em um interpretador comum. Copie o que precisar ou teste cada trecho ao vivo no playground de Lua - sem necessidade de instalação.
Perguntas frequentes sobre a folha de consulta Lua
Esta folha de consulta Lua é gratuita?
Sim. Esta folha de consulta Lua é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar uma operação de tabela, uma função de string ou uma palavra-chave de controle de fluxo.
Como uma tabela Lua pode ser ao mesmo tempo um array e um map?
Uma tabela é apenas um conjunto de pares chave-valor, e a chave pode ser qualquer valor. Quando você usa chaves inteiras consecutivas começando em 1 (
{10, 20, 30}), a tabela se comporta como um array; quando você usa chaves de string ({name = "Ada"}), ela se comporta como um map. Você pode até misturar os dois na mesma tabela. É por isso que Lua só precisa de um tipo estruturado - a tabela cobre arrays, dicionários, conjuntos e objetos.Por que Lua usa indexação com base 1?
Por convenção e por design, os arrays em Lua começam no índice 1, não no 0 - então
t[1] é o primeiro elemento e #t é a contagem. O operador de comprimento # e funções de biblioteca como table.insert e ipairs assumem essa convenção de base 1, então manter-se fiel a ela mantém seu código de array funcionando como esperado.Posso praticar Lua online?
Sim. Abra o playground de Lua para executar qualquer trecho desta folha de consulta no seu navegador - sem instalação de Lua. Quando quiser estrutura, o curso interativo e gratuito de Lua da Coddy leva você passo a passo de variáveis e tabelas a funções e metatables.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos tópicos mais comuns (variáveis, strings, tabelas, controle de fluxo) até os avançados (as bibliotecas padrão e as metatables), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para o resto.
Recursos relacionados
Mais folhas de consulta
