Lua 5.3

Conceitos Básicos

Lua é uma linguagem de programação multiparadigma, interpretada (executa bytecodes em uma VM baseada em registradores [register-based virtual machine]), tipagem dinâmica e gerenciamento automático de memória com incremental garbage collection.
Lua é uma linguagem escrita em C ANSI.

Dinamicamente tipada: Variáveis em Lua não tem tipos, apenas valores. Não há definição de tipos na linguagem para as variáveis.

Tipos

Todos os valores em Lua são first-class values.

Lua tem 8 tipos básicos: nil, boolean, number, string, function, userdata, thread e table.

nil: tem valor único = nil, que deve ser diferente de qualquer outro valor. Representa ausência de valor.

boolean: tem dois valores, true e false, nil e false tornam uma condição falsa, qualquer outro valor é true.

number: representa tanto números inteiros (integer) quanto números reais (floating-point). (O tipo number usa duas representações internas, ou dois subtypes: int e float, por padrão os dois 64-bit).

string: representa uma sequência imutável de bytes. Também é 8-bit clean, suporta qualquer valor de 8-bit.

function: maneira de representar e manipular funções escritas em Lua e também em C.

userdata: permite que dados em C sejam armazenados um bloco de memória (raw memory) em Lua (apenas pode ser usado pela API C).

thread: representa threads independentes e é usado para implementar corotinas (coroutines ou collaborative multithreading).

table: Implementa associative array, ou seja, um vetor associativo que pode ter como índices não apenas números, mas qualquer valor de Lua, exceto nil. As tabelas podem ser heterogêneas; isto é, eles podem conter valores de todos os tipos (exceto nil). Qualquer chave com valor nulo não é considerada parte da tabela. Por outro lado, qualquer chave que não faça parte de uma tabela tem um valor nulo associado. As tabelas são o único mecanismo de estruturação de dados em Lua; podem ser usadas ​​para representar arrays (vetores e matrizes), lists, symbol tables, sets, records, graphs, trees, hash table, etc.

Elementos Léxicos

Os identificadores em Lua podem ser qualquer sequência de letras, dígitos e sublinhados (underscore), não começando com um dígito e não sendo uma palavra reservada da linguagem.

Lua é uma linguagem case sensitive, ou seja, diferencia letras maiúsculas e minúsculas. Por convenção, deve-se evitar o uso de identificadores com underscore e letra maiúsculas, como por exemplo: _VERSION.

Comentários curtos (uma linha) são feitos com -- (dois hífens), para comentários longos (mais de uma linha) se utiliza dois traços seguidos de dois colchetes de abertura --[[ e dois colchetes de fechamento ]], veja o exemplo abaixo:

-- comentário de uma linha --[[ comentário em duas linhas --]] 

Palavras Reservadas

Lua possui 22 palavras reservadas, são elas:

Outros tokens da linguagem:

Variável

Existem 3 tipos de variáveis: variáveis globais, variáveis locais e campos da tabela. Todas as variáveis por padrão tem escopo global, a menos que declarada explicitamente como local. Antes da primeira atribuição a uma variável, seu valor é nil.

Criando variáveis:

var1 = 33 -- tipo number, int var2 = 33.0 -- tipo number, float ok = true -- tipo boolean, valor verdadeiro nao_ok = false -- tipo boolean, valor falso lang = 'Linguagem Lua' -- tipo string, usando aspas duplas lang = 'Linguagem Lua' -- tipo string, usando aspas simples -- string com mais de uma linha, se usa colchetes lang = [[Linguagem de programação Lua]] -- table lista = {1.33, 5.8, 7.8} -- tipo table lista2 = {1, 5, 10, 1000} -- tipo table agenda = {pedro = '1234-4321', amanda = '5555-5555'} 

Para criar variáveis locais, é necessário usar a palavra reservada local, veja:

local var1 = 44.5 local lista = {1, 4, 5, 6} 

Lua permite múltiplas atribuições, do lado esquerdo uma lista de variáveis e do lado direito uma lista de expressões, os elementos são separados por vírgula:

-- a tem o valor 100 -- b tem o valor 200.5 -- c tem o valor 'lua' a, b, c = 100, 200.5, 'Lua' -- swap a, b = 1, 2 -- a = 1, b = 2 a, b = b, a -- a = 2, b = 1 

Operações Matemáticas

Lua suporta as seguintes operações aritméticas:

Com exceção do operador de exponenciação ^ e de divisão inteira //, os operadores aritméticos funcionam da seguinte maneira:

• Se os dois operandos são números inteiros (int), a operação é executada sobre números inteiros e o resultado é um número inteiro.

• Caso contrário, se ambos os operandos forem números ou strings que podem ser convertidos em números, eles serão convertidos em float, a operação será executada seguindo as regras usuais para aritmética de ponto flutuante, e o resultado é um float.

A exponenciação ^ e a divisão / sempre convertem seus operandos em float e o resultado é sempre float.

A divisão inteira // é uma divisão que arredonda pra baixo o número.

Módulo % é o resto da divisão inteira.

Divisão por 0 (zero) não gera uma exceção, mas retorna um valor numérico inf

inf = valor infinito, por exemplo

10/0 -- retorna inf 

nan = Not a Number, é um valor especial usado para representar resultados numéricos indefinidos ou não representáveis, por exemplo:

0/0 -- nan 

Operadores Relacionais

Lua suporta os seguintes operadores relacionais:

Todos os operadores retornam um valor tipo boolean, que pode ser true ou false.

A igualdade == primeiro compara o tipo de seus operandos. Se os tipos forem diferentes, o resultado será falso. Caso contrário, os valores dos operandos são comparados.

Table, userdata e threads são comparados por referência: dois objetos são considerados iguais apenas se forem o mesmo objeto. Sempre que você cria um novo objeto esse novo objeto é diferente de qualquer objeto existente anteriormente.

O operador ~= é a negação da igualdade ==.

As comparações de igualdade == não converte string para number, ou number para string. Sempre irá retornar false, e o operador ~= retorna true:

'0' == 1 -- false '0' == 0 -- false '0' ~= 1 -- true '0' ~= 0 -- true 

Seguindo o padrão IEEE 754, o nan é considerado nem menor, nem igual, nem maior que qualquer valor (incluindo ele próprio).

Operadores bit-a-bit

Lua suporta os seguintes operadores bit-a-bit:

Operadores lógicos

Os operadores lógicos em Lua são and, or, e not.

Todos os operadores lógicos consideram false e nil como false e qualquer outra coisa como true. As expressões lógicas são avaliadas por curto-circuito (short-circuit evaluation), ou seja, o segundo operando é avaliado apenas se necessário. aqui estão alguns exemplos:

O operador de negação (not) sempre retorna true ou false.

O operador and retorna seu primeiro argumento se esse valor for false ou nil, caso contrário, e retorna seu segundo argumento.

O operador or retorna seu primeiro argumento se esse valor for diferente de nil e false; caso contrário, or retorna seu segundo argumento.

Vejamos os exemplos abaixo com nan, inf e nil:

or:

2 or nil -- 2 nil or 2 -- 2 2 or nan -- 2 nan or 2 -- 2 'Lua' or nil -- 'Lua' 'Lua' or nan -- 'Lua' 'Lua' or inf -- 'Lua' 2 or error() -- 2 

and:

2 and nil -- nil nil and 2 -- 2 2 and nan - nil nan and 2 -- nil 'Lua' and nil -- nil 'Lua' and nan -- nan 'Lua' and inf -- inf 

not:

not 2 -- false not 'lua' -- false not nil -- true not nan -- true not inf -- true not not 2 -- true not true -- false not false -- true 

Precedência

A precedência de operadores em Lua, do maior para o menor:

• parênteses: (, )
• exponenciação: ^
• operadores unários: not, #, -, ~
• multiplicação: *
• divisão: /
• divisão inteira: //
• módulo: %
• adição: +
• subtração: -
• concatenação de string: ..
• operadores bit a bit: <<, >>, &, ~, |
• operadores relacionais: <, >, <=, >=, ~=, ==
• operadores lógicos: and, or

Os operadores de concatenação .. e exponenciação ^ são associativos-à-direita. E todos os outros operadores binários são associativos-à-esquerda.

Estruturas de Controle

Em Lua temos estruturas de decisão (condicional) e de repetição, semelhante a qualquer outra linguagem de programação. (Lua a partir da versão 5.2 incluiu o comando goto).

Estrutura Condicional

--[[ *exp* é qualquer trecho de código Lua que está realizando alguma operação lógica. Em uma expressão os valores em Lua como nil e false sempre retornam false, qualquer outro valor retorna true. *block* é qualquer trecho de código Lua que será executado somente dentro do corpo do condicional --]] -- if na mesma linha if exp then block end -- ou if exp then block end -- usando else if (se senão então) na mesma linha if exp then block elseif exp then block else block end -- ou if exp then block elseif exp then block else block end 

Estrutura de Repetição

Para os nossos loops usamos os clássicos while, repeat–until e for.

Usando while e repeat–until

-- while: enquanto *exp* for verdadeira faça -- no while verifica a *exp* primeiro, depois executa *block* -- mesma linha while exp do block end -- ou while exp do block end -- repeat–until, repita até que *exp* seja verdadeira -- em repeat primeiro executa o bloco e depois verifica a exp -- mesma linha  repeat block until exp do -- ou repeat block until exp 

Usando o for

O loop for em Lua tem duas formas diferentes, uma é um for numérico e outra um for genérico (veja as funções pairs e ipairs na seção sobre funções Embutidas):

for numérico

-- inicial = número inicial -- limite = número limite for var = inicial, limite do block end -- ou na mesma linha for var = inicial, limite do block end 

Há um terceiro parâmetro opcional: passo (step),

--[[ passo tem um valor padrão de 1, pois o loop vai de 1 em 1 iterando os elementos do valor inicial ao limite, se mudarmos para 2, a iteração será de 2 em 2 --]] for var = inicial, limite, passo do block end -- na mesma linha for var = inicial, limite, passo do block end -- exemplo for i = 1, 10, 2 do print(i) end - ou na mesma linha for i = 1, 10, 2 do print(i) end -- saida: 1, 3, 5, 9 -- exemplo, tabuada do 5 for i = 1, 10 do print("5 x", i, "=", 5 * i) end --[[ saída: 5 x 1 = 5 5 x 2 = 10 5 x 3 = 15 5 x 4 = 20 5 x 5 = 25 5 x 6 = 30 5 x 7 = 35 5 x 8 = 40 5 x 9 = 45 5 x 10 = 50 --]] 

Comando break

Para sair (interromper) a execução de um loop usamos o comando break

-- loop infinito while true do print("entrou no loop...") break -- interrompe na primeira iteração print("nunca será executado") end -- outro exemplo -- observe a linha onde incrementamos nosso 'contador' i local i = 1 while i < 10 do print("entrou no loop") if i == 3 then break end i = i + 1 -- incremento end print(i) -- 3 --[[ saída: entrou no loop entrou no loop entrou no loop 3 --]] -- no loop for for i = 1, 10 do print("entrou no loop") break -- interrompe end print("saiu do loop") for i = 1, 10 do print("entrou no loop") if i == 3 then break end end print("saiu do loop") --[[ saída: entrou no loop entrou no loop entrou no loop saiu do loop --]] 

Funções

Como todos os outros tipos em Lua, function também é first-class-value, isso significa que você pode atribuir uma função a uma variável, passar uma função por parâmetro e retornar um função como valor.

Por padrão as funções são anônimas, você atribui a função a uma variável, como por exemplo:

diga_ola = function() print("olá!") end -- executando diga_ola() -- imprime "olá" -- pode ser escrita em uma única linha diga_ola = function() print("olá!") end -- Lua fornece syntactic sugar para a definição -- a função escrita abaixo é equivalente a versão de cima. function diga_ola() print("olá") end 

Ao usar o syntactic sugar, Lua transcreve a função para o formato anônimo. Essas duas formas são equivalentes.

function nome_da_funcao() block end 

para

nome_da_funcao = function() block end 

Funções podem ter zero ou mais parâmetros e podem ter nenhum ou múltiplos retornos (se usa no final do corpo da função a palavra reservada return), veja:

-- função com 2 parâmetros e 1 retorno soma = function(a, b) local c = a + b return c end v1 = soma(10, 15) -- v1 = 25 -- 2 parâmetros e 2 retornos somar_multiplar = function(a, b) local c = a + b local d = a * b return c, d end v1, v2 = somar_multiplar(34, 12) -- v1 = 46, v2 = 408 

Funções podem receber um número variável de parâmetros(variadic functions), para isso, como último parâmetro use ..., veja no exemplo:

imprimir = function(...) print(...) end imprimir(1,2,3,4,5,6) -- saída: 1 2 3 4 5 6 imprimir("lua", ".org") -- saída: lua .org 

O escopo de uma função por padrão é global, mas podemos alterar usando a palavra reservada local

local soma = function(a, b, c) return a + b + c end v = soma(5, 3, 1) -- v = 9  

Tabela

Em Lua existe uma única estrutura de dados: table.

-- criando uma variavel table a = {} -- vazia -- usamos o operador unário # para descobrir o tamanho da table #a -- 0 -- criando com elementos a = {1, 2, 3, 4, 5, 6} -- funciona como um vetor a = {1, 2, "Lua", 3, "Linguagem"} -- heterogenea --[[ quando usado como um vetor, podemos acessar via colchetes passando um índice --]] a[1] -- 1 a[2] -- 2 a[3] -- "Lua" linguagem = a[3] -- linguagem = "Lua" print(linguagem == "Lua") -- true --[[ o índice em em Lua começa em 1 e não em 0 como nas demais linguagens --]] -- podemos colocar outro table como valor a = {1, 2, "Lua", {"linguagem", "PUC"}, "roberto"} #a -- tamanho: 5 a[3] -- "Lua" a[4] -- table: 0x55a93478f110 -- acessando a tabela dentro da tabela a[4][1] -- "linguagem" a[4][2] -- "PUC" a[4][3] -- indice não existe, retorna nil nome_prof = a[5] -- roberto print("professor:", nome_prof) -- professor: roberto a[6] -- nil --[[ usando table como tabela hash, ou (dict em Python), um par de chave-valor (key-value) --]] a = {nome = "Roberto", funcao = "professor"} -- acessamos através da chave nome e operador . (ponto) a.nome -- "Roberto" a.funcao -- "professor" a.outro -- nil -- podemos acessar por colchetes a["nome"] -- "Roberto" a["outro"] -- nil -- inserindo um novo par chave-valor a.outro = "Knuth" -- ou de outra forma a["outro"] = "Knuth" -- tabelas podem armazenar funções somar = function(x, y) return x + y end a = {5, 7, somar} a[3](a[1], a[2]) -- 12 -- usando . (ponto) a = {} a.valor = 5 a.valor2 = 7 a.f = somar a.f(a.valor, a.valor2) -- 12 

Biblioteca Padrão (Standard Libraries)

Toda linguagem de programação fornece um conjunto de bibliotecas (funções) que estão disponiveis por padrão. A Biblioteca padrão de Lua é implementada diretamente por uma API em C, e é pequena, enxuta, porém, eficiente.

Funções Embutidas

As funções disponíveis por padrão, ou funções embutidas (built-in function) são: assert, collectgarbage, dofile, error, getmetatable, ipairs, load, loadfile, next, pairs, pcall, print, rawequal, rawget, rawlen, rawset, select, setmetatable, tonumber, tostring, xpcall e type. E duas variáveis globais _VERSION e _G.

Funções básicas

assert (v [, message]) levanta um erro (message) caso v seja falso, se v for verdadeiro retorna todos os argumentos:

v, m = assert(2 == 2, 'ok') -- v = true, m = 'ok' -- v = true, m = 'ok', n = 'ok2', o = 'ok3' v, m, n, o = assert(2 == 2, 'ok', 'ok2', 'ok3') -- levanta um erro assert(false, "errado!") stdin:1: errado! stack traceback: [C]: in function 'assert' stdin:1: in main chunk [C]: in ? 

print (···) recebe qual número de parâmetros e os imprime na tela:

print("Olá Lua") Olá Lua print("Olá", "Lua") Olá Lua print("Olá", "Lua", "Linguagem") Olá Lua Linguagem -- imprime a referência da tabela print({linguagem = "Lua"}) table: 0x559004645b70 a = {10, 20, 30} print(a[3]) 30 

type (v) retorna uma string com o tipo de v

type(1) number type(1.5) number type('Lua') string type(print) function type({}) table type(nil) -- retorna uma string 'nil' não o valor nil nil type(type(nil)) string type(nan) nil > type('') string type(type) function 

tostring(v) converte o valor v para uma string

tostring("aa") aa tostring(print) function: 0x559002715db0 tostring("Lua") Lua tostring(2020) 2020 tostring(3.14) 3.14 tostring(print) -- string da referência function: 0x559002715db0 tostring({1, 2, 3}) -- string da referência table: 0x559004647b80 

tonumber (e [, base]) converte o valor e para number. Se o valor não pode ser convertido para number retorna nil.

tonumber("2.3") -- 2.3 tonumber("2,3") -- nil tonumber("{}") -- nil tonumber("Lua") -- nil tonumber({}) -- nil tonumber(print) -- nil 

dofile ([filename]) abre um arquivo Lua e executa seu conteúdo, se o arquivo não estiver no formato correto ocorrerá um erro.

--[[ crie outro arquivo teste.lua, por exemplo e dentro dele coloque códigos Lua: soma = function(a,b) return a+b end a, b = 4, 5 c = soma(a, b) --]] -- carrega e executa o arquivo dofile("teste.lua") print(a) -- 4 print(b) -- 5 print(c) -- 9 print(soma(3,3)) -- 6 

error (message [, level]) leventa um erro com o texto de message, por padrão level = 1

error("Mensagem de Erro") Mensagem de Erro stack traceback: [C]: in function 'error' stdin:1: in main chunk [C]: in ? 

load (chunk [, chunkname [, mode [, env]]]) carrega um trecho de código Lua, retorna dois valores, o primeiro é uma função o segundo é nil caso não tenha acontecido nenhum erro, ou uma string com a mensagem do erro

f, err = load("x = 2 + 3") print(x) nil f() -- executa o conteúdo x = 2 + 3 print(x) 5 print(err) nil -- com erro f, err = load("x 2 + 3") -- erro sintático f() -- executa o conteúdo x 2 + 3, levanta um erro stdin:1: attempt to call a nil value (global 'f') stack traceback: stdin:1: in main chunk [C]: in ? print(err) [string "x 2 + 5"]:1: syntax error near '2' 

loadfile ([filename [, mode [, env]]]) igual o load() porém carrega de um arquivo.

pcall (f [, arg1, ···]) Executa a função f com os argumentos fornecidos de modo protegido. Isso significa que qualquer erro dentro de f não é propagado; em vez disso, o pcall captura o erro e retorna um código de status. Seu primeiro resultado é o código de status (um boolean), que é true se a chamada for bem-sucedida sem erros. Nesse caso, pcall também retorna todos os resultados da chamada, após este primeiro resultado. Em caso de erro, pcall retorna false mais a mensagem de erro.

soma = function(a, b) return a + b end status, r = pcall(soma, 2, 3) print(status) true print(r) 5 status, r = pcall(soma, "a", 3) -- erro print(status) false print(r) -- string stdin:1: attempt to perform arithmetic on a string value (local 'a') -- exemplo com mais de um retorno soma = function(a, b) return a + b, "Lua" end status, r, r2 = pcall(soma, 2, 3) print(status) true print(r) 5 print(r2) "Lua" -- com erro status, r, r2 = pcall(soma, "a", 3) print(status) false print(r) stdin:1: attempt to perform arithmetic on a string value (local 'a') -- o restante dos parâmetros ficam como nil  print(r2) nil 

xpcall (f, msgh [, arg1, ···]) Essa função é semelhante à pcall, exceto que define um novo manipulador de mensagens msgh (function).

erro_msg = function() return "Deu errado!" end soma = function(a, b) return a + b end status, r = xpcall(soma, erro_msg, 2, 3) print(status) true print(r) 5 -- com erro status, r = xpcall(soma, erro_msg, "a", 3) print(status) false print(r) Deu errado! status, r = xpcall(soma, function() return error() end, "a", 3) print(status) false print(r) error in error handling 

select (index, ···) Se index for um número, retornará todos os argumentos após o índice do número do argumento; um número negativo é indexado a partir do final (-1 é o último argumento). Caso contrário, o índice deve ser a string com '#' e o select retorna o número total de argumentos extras recebidos.

select(3, 1, 2, 3, 4, 5, 6) 3 4 5 6 select(5, 1, 2, 3, 4, 5, 6) 5 6 select('#', 1, 2, 3, 4, 5, 6) 6 select('#', 1, 2, 3) 3 select('#', {1,2,3}) 1 select(1, {1,2,3}) table: 0x55a350147720 select(2, {1,2,3}) -- nil -- usando com vararg funcao = function(...) print (select(1, ...)) print (select(2, ...)) print ("quantidade: " .. select('#', ...)) end funcao(1, 2, 3) 1 2 3 2 3 quantidade:3 funcao(1, 2) 1 2 2 quantidade:2 

next (table [, index]) Permite percorrer todos os campos de uma tabela. Seu primeiro argumento é uma tabela (table) e seu segundo argumento é um índice (number) nesta tabela. next retorna o próximo índice da tabela e seu valor associado. Quando chamado com nil como seu segundo argumento, o next retorna o índice inicial e seu valor associado. Quando chamado com o último índice ou com nil em uma tabela vazia, o next retorna nil. Se o segundo argumento estiver ausente, ele será interpretado como nil. Em particular, você pode usar next(t) para verificar se uma tabela está vazia.

tab = {10, 20, 30, 40, 50} next(tab) 1 10 next(tab, nil) 1 10 next(tab, 1) 2 20 next(tab, 3) 4 40 next(tab, 4) 5 50 next(tab, 5) nil 

rawget (table, index) Obtém o valor real de table[index], sem chamar o metamétodo __index. index pode ser qualquer valor.

tab = {10, 20, 30, 40, 50} rawget(tab, 1) 10 rawget(tab, 2) 20 rawget(tab, 3) 30 rawget(tab, 4) 40 rawget(tab, 5) 50 rawget(tab, 6) nil 

rawlen(v) Retorna o tamanho do objeto v, pode ser uma table ou uma string, sem invocar o metamétodo __len. Retorna um número inteiro.

rawlen("") 0 rawlen("abc") 3 rawlen("abc123") 6 rawlen({}) 0 rawlen({1,2,4}) 3 rawlen({1,2,3, "lua"}) 4 rawlen({1,2,3, "lua",{}}) 5 

rawset(table, index, value) Define o valor real da table[index] como value, sem chamar o metamétodo __newindex. table deve ser uma tabela, index qualquer valor diferente de nil e NaN e value qualquer valor de Lua. Esta função modifica e retorna a própria table.

tab = {10, 20, 30} print(tab[4]) -- nenhum valor no indice 4 nil tabela = rawset(tab, 4, "Lua") print(tab[4]) Lua print(tabela[4]) Lua tabela = rawset(tab, 1, "Linguagem") print(tab[1]) Linguagem print(tabela[1]) Linguagem 

rawequal(v1, v2) Verifica se v1 é igual a v2, sem chamar o metamétodo __eq. Retorna um boolean.

tab = {10,20} t = {10,20} tab == t false rawequal(tab, t) false rawequal(tab[1], t[1]) true tab[1] == t[1] true rawequal("Lua", "Lua") true f = function() return "Lua" end rawequal(f, f) true f2 = function() return "Lua" end f == f2 false rawequal(f, f2) false 

ipairs (t) Retorna 3 valores (um iterator function, a tabela t, e o valor 0). Itera sobre os pares de chave-valor (1, t[1]), (2, t[2]) até o primeiro valor nil.

--- usa no for generico t = {10, 20, 30, 40} for k, v in ipairs(t) do print(k, v) end 1 10 2 20 3 30 4 40 -- inserindo um valor nil no meio da tabela t t = {10, 20, nil, 30, 40} for k, v in ipairs(t) do print(k, v) end 1 10 2 20 -- note que iterou até o valor nil ser lido e encerrou. --[[ se tivermos um elemento no formato chave = valor ele não é lido, é ignorado. --]] t = {10, 20, linguagem = "Lua", 30, 40} > for k, v in ipairs(t) do print(k, v) end 1 10 2 20 3 30 4 40 

pairs(t). se t tem um metametodo __pairs, chama-o com t como argumento e retorna os três primeiros resultados da chamada.
Caso contrário, retorna três valores: a função next, a tabela t e nil. pairs itera sobre todas os pares chave-valor.

t = {10, 20, 30} for k, v in pairs(t) do print(k, v) end 1 10 2 20 3 30 t = {10, 20, nil, 30, 40} > for k, v in pairs(t) do print(k, v) end 1 10 2 20 4 30 5 40 -- com chave-valor no meio da tabela t = {10, 20, nome = "Lua", 30, 40} for k, v in pairs(t) do print(k, v) end 1 10 2 20 3 30 4 40 nome Lua t = {10, 20, nome = "Lua", 30, 40, autor = "Roberto", lab = "TecGraf"} for k, v in pairs(t) do print(k, v) end 1 10 2 20 3 30 4 40 autor Roberto nome Lua lab TecGraf 

Outros Recursos

Ficaram de fora dessa introdução:

• As bibliotecas: coroutine library, package library, string manipulation, basic UTF-8 support, table manipulation, mathematical functions, input and output, operating system facilities, debug facilities.

Esses recursos serão explicados em outros posts, e podem ser conhecidos através do Lua Reference Manual.

Referências e Links importantes

• Site Oficial: Lua.org

• Referência Oficial da Linguagem: Lua 5.3 Reference Manual

• Livro escrito por um dos autores da linguagem: professor Roberto Ierusalimschy, versão online (Lua 5.0) está desatualizado mas é fundamental Programming in Lua (first edition)

• Ebook: Programming in Lua, Fourth Edition Author: Roberto Ierusalimschy

• Book: Programming in Lua, Fourth Edition Author: Roberto Ierusalimschy

• Site dos usuários de Lua, vários documentos, exemplos, tutoriais, etc Lua-users

• Página do professor Fabio Mascarenhas da UFRJ: Curso de Lua https://dcc.ufrj.br/~fabiom/lua/