Axuda:Lua

if cor == 'negro' then
    cssCor = '#000'
end

if cor == 'negro' then
    cssColor = '#000'
else
    cssCor = cor
end

if cor == 'negro' then
    cssCor = '#000'
elseif cor == 'branco' then
    cssCor = '#fff'
else
    cssColor = color
end

Os signos == comproban a igualdade. Un só signo = asigna un valor.

Bucle for:

f = 1 -- asigna o valor inicial
for i = 1, 5 do
    f = f * i
end
return 'O factorial de 5 é ' .. f

Os dous guións - designan un comentario. Os dous puntos seguidos .. concatenan dúas cadeas de caracteres ou variables.

Declaración de funciones:

local function getColour()
    return 'azul'
end

local function plural(mundo)
    return mundo .. 's'
end

local p = {}
function p.ola()
    return '¡Ola mundo!'
end
return p

Para chamar á función:

colour = getColour()
colorPlural = plural('azul')

Hai tres tipos de variables: variables globais, variables locais e táboas. Unha variable considerase global a non ser que se declare explicitamente coa clave local. Unha variable local é visible dentro do bloque onde foi declarada. Unha variable declarada sen asignación ten valor nil (nulo).

x = 10           -- variable global
do               -- novo bloque
    local x = x  -- nova x asignada ao valor da anterior
    x = x + 1    -- 11
end              -- pecha o bloque e as súas variables locais
return x         -- 10, a global

local x
if ready then
    x = 'vai aló'
end
-- x é 'vai aló' se
-- ready, se non é nulo

Creación dunha táboa:

números = {un = 1, dous = 2, tres = 3}

Acceso a un elemento da táboa:

return números.dous    -- retorna 2
return números['dous'] -- tamén retorna 2

Táboa numerada:

africanFlatbreads = {
    'Aish Mehahra',
    'Injera',
    'Lahoh',
    'Ngome'
}
return africanFlatbreads[2] -- retorna 'Injera'

Iteración de elementos da táboa:

for nome, número in pairs(números) do
    ...
end

for index, bread in ipairs(africanFlatbreads) do
    ...
end

• Formato de comentarios:

    -- comentario nunha única liña
    --[[
    comentario largo
    --]]

• Ignóranse os saltos de liña.
• Os puntos e comas para terminar as declaracións son opcionais e non recomendados.

• Cadea de caracteres (string), entre comiñas simples ('...') ou dobres ("..."). (8-bit)
• Numèricos, un único formato de punto flotante de precisión doble.
• Booleano: "true" ou "false" (verdadeiro ou falso)
• "Nil" (nulo)
• Táboas
  • Implementadas coma hashtable
  • Empregadas para OOP, com Javascript
  • Sintaxe literal: {nome = valor} ou {a, b, c}
  • Acceso con foo.bar ou foo['bar']
• Funcións
  • Valores de primeira clase.
  • Retornan valores múltiples.
  • Os valores de retorno múltiples non están ligados a un tipo de dato.
  • Sintáxe anónima

x = function()
    ...
end

• Non igual: ~= (en lugar de !=)
• Concatenación: ..
• Lonxitude: #
• Lóxicos: and, or, not

if lacón and grelos then
    return 'cocido'
end

if pomba or águia then
    return 'paxaro'
end

if not dormido then
    return 'esperto'
end

• Exponencial: ^
• Có significado habitual: <, >, <=, >=, ==, +, -, *, /, %
• Operadores omitidos:
  • Ningún operador de asignación con +=. Un só igual = non se considera realmente un operador.
  • Ningún operador bit a bit
  • Ningún operador ternario ?:
• Asignación. Coma en BASIC, a asignación é unha declaración completa, no unha expresión.

a, b = c, d
a, b = foo()

local a, b = c, d
local a = b, c = d -- así non!

• Variables
  • Ámbito léxico, case idéntico a JavaScript.
  • Unha variable non determinada é idéntica a unha variable nula.
  • Ningunha sintaxe especial para suprimir, simplemente x = nil.
  • O acceso a variables non definidas non xera erros.
• Obxectos
  • Feitos con táboas, empregando unha variedade de sintaxe, semellante á JavaScript.
  • Variables de elementos privados implementadas con ámbito léxico, coma en JavaScript.
  • Punto para métodos estáticos: obj.func ()
  • Dous puntos para métodos non estáticos: obj: func ()
  • Exemplo de estilo de construción dunha función:

function newObj()
    local private = 1
    local obj = {}
    function obj:getPrivate()
        return private
    end
    return obj
end

• Metatáboas
  • Cada táboa pode ter unha metatáboa asociada
  • Proporciona sobrecarga de operadores
  • O campo índice da metatáboa emprégase para a herdanza de obxectos e a programación baseada en prototipos.

Todo o código Lua está no espazo de nomes "Módulo".

Invocación:

{{ #invoke: nome_módulo | nome_función | arg1 | arg2 | nome1 = valor1 }}

As instancias de invocación son illadas, os globais definidos nunha non están dispoñibles noutra.

Un módulo é un bloque Lua que retorna unha táboa de exportación. Proporcionase require () e a libraría package. A función de exportación retorna unha cadea de texto wiki, convertendo os valores que non son string. Os valores múltiples de retorno son concatenados.

Métodos frame:

• args:

local nome1 = frame.args.nome1

• argumentPairs():

local t = {}
for nome, valor in frame:argumentPairs() do
    t[name] = value
end

• getParent(): Proporciona acceso ao frame superior, por exemplo os argumentos do modelo que chamou #invoke
• Preproceso de texto wiki

frame:preprocess('{{modelo}}')

• Invocación estructurada de modelo

frame:expandTemplate{
    title = 'modelo',
    args = {foo = foo}}

Os argumentos son sempre expandidos. Non é necesario construír preprocesar as entradas dos argumentos.

• Wikipedia:Guía de estilo de Lua
• Scribunto/Lua referencia manual en Mediawiki (en inglés)

• Programming in Lua (en inglés)
• Manual de referencia ver 5.1 (en castelán)
• Manual de referencia ver 5.2 (en inglés)
• Lua-users (en inglés)