Ajuda:Lua

Lua é uma linguagem de programação usada nos módulos da Wikipédia através da extensão Scribunto. Esta página pretende apresentar a linguagem de uma forma resumida, para uma compreensão mais completa sobre a linguagem veja o manual de referencia Lua da extensão.

Nos módulos a linguagem é praticamente igual ao Lua versão 5.1, removidas algumas funções que não fazem sentido dentro da Wikipédia e adicionadas algumas que ajudam a trabalhar com a estrutura do código-wiki. Então tutoriais sobre a linguagem Lua em geral também são úteis no aprendizado da linguagens, veja por exemplo a a documentação oficial da linguagem em português e o tutorial de lua-users.org.

Para usar um módulo em uma página da Wikipédia ele precisa retornar uma tabela com funções, essas funções podem então ser invocadas com a sintaxe {{#invoke:nome do módulo|função do módulo|argumentos passados para o frame}}. Os argumentos passados para o frame são como os argumentos de uma predefinição, só que em vez de estarem disponíveis nos formatos {{{1}}}, {{{2}}} ou {{{alguma palavra}}} estão disponíveis em frame.args, que é uma tabela Lua {['1']='valor equivalente a {{{1}}}', ['2']='valor equivalente a {{{2}}}'}.

Estruturas básicas

Diferentemente do que acontece nas predefinições, onde todos os dados são tratado como texto ou números, em Lua existe tipos diferentes de estruturas de dados, e elas são armazenadas em variáveis. Os principais tipos de estruturas de dados usadas em Lua são: nil, true, false, números, strings (texto), funções e tabelas. Elas podem ser declaradas da seguinte forma:

nulo = nil
verdadeiro = true
falso = false
-- isto é um comentário, tudo que for escrito após -- é ignorado pelo código
numero = 123  -- os nomes das variáveis não podem conter acentos
texto = 'isto é uma string, ou texto'
funcao = function(n)
    local resposta = (n + numero) * 2 -- uma variável local só é acessível dentro do trecho em que foi declarada
    return 'o valor de (' .. n .. ' + ' .. numero .. ') × 2 é ' .. resposta
end -- funções devem ser terminadas com end
x = funcao(8)  -- o valor da varaável x será 'o valor de (8 + 123) × 2 é 262'
tabela = {'este é o valor 1', 'este é o valor 2', x = 'este é o valor x', ['y'] = 'este é o valor y',
  ['número'] = 2,  -- quando declarado neste formato a chave de um valor da tabela pode conter acento
  ['tabela'] = {'tabela', 'dentro', 'da', 'tabela'},
  ['número 123'] = numero,  -- adicionando um valor que está em outra variável
  ['função'] = funcao  -- nesse caso o valor é uma função
}

nil, true, false e operadores lógicos

nil é um valor especial que indica a ausência de valor, ao tentar obter o valor de uma variável que não existe o valor retornado será nil, e quando uma variável local é declarada sem um valor específico, seu valor inicial será nil.

true e false são usados quando uma variável só admite dois valores, verdadeiro ou falso. É um valor geralmente retornado por operações de comparação como x > 5 ou y ~= ''.

Em algumas operações as expressões são transformadas em valores true ou false para serem processadas. Esse é o caso dos operadores and e or e das declarações if e while. Mas é preciso ter atenção porque diferentemente de outras linguagens de programação, 0 (zero), '' (string vazia) e {} (tabela vazia) são considerados true.

O and e or são operadores lógicos. Considerando duas expressões e1 e e2, e1 and e2 retorna e1 se e1 for falso e retorna e2 se e1 for verdadeiro, e1 or e2 retorna e1 se e1 verdadeiro e e2 se e1 for falso. Isso é útil quando se deseja testar várias condições ou retornar valores diferentes de acordo com alguma condição sem usar o if, veja alguns exemplos:

a = 32 and 76  -- a = 76
b = 28 and false  -- b = false
c = 0 or nil or 2  -- c = 0, pois 0 é considerado true
d = a and b or c and 4  -- d = 76 and false or 0 and 4, então d = 4

Operações com números

Os operadores aritméticos que podem ser usados com números são +, -, * (vezes), / (dividido), ^ (potência) e % (resto da divisão). Esses operadores só funcionam com números, porém se uma string com números for usada com esses operadores a string será transformada em número, então '2' + '3' é igual a 5.

Além dos operadores acima existem também as funções da biblioteca math.

Principais funções da biblioteca math

math.abs (x)	retorna o valor absoluto de x, ou seja, transforma em positivo se for negativo
math.ceil (x)	retorna o menor inteiro maior ou igual a x, em outras palavras, arredonda para cima
math.floor (x)	retorna o maior inteiro menor ou igual a x, em outras palavras, arredonda para baixo
math.fmod (x, y)	retorna o resto da divisão de x por y, é o mesmo que x % y
math.log (x)	retorna o logaritmo natural de x
math.log10 (x)	retorna o logaritmo de x na base 10, outras bases podem ser obtidas com divisão, pois logba = log a / log b
math.max (x, ···)	retorna o valor máximo entre os seus argumentos
math.min (x, ···)	retorna o valor mínimo entre os seus argumentos
math.modf (x)	retorna dois números, a parte integral de x e a parte fracionária de x
math.pi	retorna valor de pi
math.pow (x, y)	retorna xy, é o mesmo que usar x^y
math.sqrt (x)	retorna a raiz quadrada de x, é o mesmo que x^0.5

tabela completa em mw:Extension:Scribunto/Lua reference manual/pt-br#Math library

Veja alguns exemplos de usos de operações com números:

a = (2 * 8)^4  -- a = 16^4 = 65536
b = math.floor(math.sqrt(a) / 3)  -- b = math.floor(256 / 3) = math.floor(85.333333333333) = 85
c = math.max(a, b, 2, 10, math.abs(-1000))  -- c = math.max(65536, 85, 2, 10, 1000) = 65536

Operações com strings

A principal operação de string é a concatenação, ou seja, juntar strings, para isso se utiliza .. (dois pontos-finais), 'duas' .. ' ' .. 'palavras' se transforma em 'duas palavras'. Ao se utilizar .. com números eles são forçados a se tornarem strings, 'x = ' .. 3 se transforma em 'x = 3'. Para forçar um número a se tornar uma string também pode-se utilizar a função tostring(num).

Variáveis globais e locais

Toda variável que não for declarada como local é uma variável global, variáveis globais são acessíveis em qualquer parte do código, e é inclusive acessível pelas funções dos módulos carregados dentro do módulo principal, e da mesma forma as variáveis globais desses módulos ficam acessíveis dentro do módulo principal. Por isso é importante manter como global somente variáveis que precisam ser acessadas em outras partes do código.

A forma mais utilizada de utilizar variáveis globais é criar uma tabela para cada módulo e colocar todas as funções desse módulo que devem estar acessíveis em qualquer parte do código dentro dessa tabela, dessa forma evita-se que uma variável seja confundida com outra variável de mesmo nome em outra parte do código ou em outro módulo que tenha sido importado.

Variáveis locais são declaradas com a palavra local antes do nome da variável, variáveis locais não precisam ter um valor inicial, quando um valor inicial não for declarado o valor inicial é nil. Uma variável local só é mantida dentro do trecho em que foi declarada, se for declarada no início de uma função ela é mantida até o fim da função, se for declarada dentro de um if ela é mantida até o fim do if, o mesmo vale para else, for e outras estruturas de controle. Se uma variável for declarada local fora de uma função, ela é acessível dentro daquele módulo, outros módulos que forem carregados ou um módulo que carregar esse módulo não podem acessá-la.

Estruturas de controle

if

Um bloco if serve para executar um código somente quando uma condição é verdadeira. Após um if pode vir um elseif, que testa uma outra condição se a anterior não for verdadeira e por fim pode ter um else, que executa um código se nenhuma das condições anteriores for verdadeira. Veja exemplos do uso dessas estruturas:

f = function(x)
    if type(x) == 'number' then
        return 'o argumento passado é um número'
    elseif type(x) == 'string' then
        return 'o argumento passado é uma string'
    else
        return 'o argumento passado não um número nem uma string'
    end
end

for

O laço for faz com que um código seja repetido várias vezes. Existem duas formas de se usar o for, a mais simples é a progressão artitimética, por exemplo for i = 1, 10 do vai executar o que estiver dentro do bloco 10 vezes, na primeira vez a variável i será 1, na segunda será 2 e assim por diante, veja o exemplo a seguir.

t = {}
for i = 1, 4 do
    table.insert(t, i * 2)
end
lista = table.concat(t, ', ')  -- lista = '2, 4, 6, 8'

A outra forma de usar o for é atravez de funções iteradoras no formato for x in f() do, em que f é uma função iteradora. As principais funções iteradoras são pairs e ipairs. A função pairs é usada dentro do for no formato for k, v in pairs(t) do onde t é uma tabela. O código dentro do for será executado uma vez para cada item, em cada vez a variável k será a chave do item e v o seu valor. Como as tabelas não gravam a ordem em que os itens foram inseridos nela, as vezes é necessário usar a função 'ipairs. A ipairs funciona com a mesma sintaxe da pairs, mas itera somente os itens com chave numérica, começando pelo item 1 e continuando pelo 2, 3, 4, etc até que o próximo número não exista. Se por exemplo a tabela tiver os itens 'a', 1, 2, 3 e 5, a pairs vai iterar todos, sem uma ordem específica, já a ipairs ira iterar somente os itens 1, 2 e 3, nessa ordem, não passa pelo 'a' pois não é uma chave numérica e não passa pelo 5 pois não existe o 4. Veja o exemplo:

tabela = {[1]='banana', [2]='maçã', ['3']='mamão', [5]='abacate', ['X']='morango'}
itens_pairs = {}
itens_ipairs = {}
for chave, valor in pairs(tabela) do
    table.insert(itens_pairs, chave .. ': ' .. valor)
end
for chave, valor in ipairs(tabela) do
    table.insert(itens_ipairs, chave .. ': ' .. valor)
end
lista1 = table.concat(itens_pairs, ', ')  -- lista1 = '2: maçã, 3: mamão, 1: banana, 5: abacate, X: morango'
lista2 = table.concat(itens_ipairs, ', ')  -- lista2 = '1: banana, 2: maçã'

Ver também

• Wikipédia:Lua
• mw:Extension:Scribunto/Lua reference manual/pt-br