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ásicasEditar
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ógicosEditar
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úmerosEditar
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.
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 stringsEditar
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)
.
Operações com tabelasEditar
FunçõesEditar
Variáveis globais e locaisEditar
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 controleEditar
ifEditar
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
forEditar
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çã'