Ayuda:Lua

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
  Inicio   Discusión   Ayuda e introducción   Módulos disponibles   Zona de pruebas  


Gran parte de esta página está basada en la presentación en PDF de Tim Starling del hackathon 2012 de Berlín

Bienvenidos a la introducción de Lua con Scribunto, la página de ayuda para los principiantes para aprender a hacer scripts Lua en MediaWiki, y un resumen para programadores más avanzados.

El contenido está destinado principalmente a los desarrolladores familiarizados con las plantillas de MediaWiki. Si eres un experto en plantillas MediaWiki, pero recién llegado a Lua, aprenderáss algunas nuevas instrucciones mágicas. Si tiene experiencia con Lua pero no con plantillas, puede encontrar más información en Ayuda: Plantilla. Tenga en cuenta que algunas cosas de Scribunto no se aplican en la distribución Lua. Si no sabe ni lo uno ni lo otro, encontrará que en la comunidad de Wikipedia hay gente dispuesta a ayudarle.

Introducción para nuevos programadores[editar]

Hola mundo[editar]

El primer ejercicio típico es saber escribir Hola mundo con el nuevo lenguaje. Cree una página en el espacio de nombres Module. El formato recomendado para pruebas es: Module:Zona de pruebas/nombre de usuario/nombre del módulo. A continuación se explica en detalle el formato de Módulo:Demo:


local p = {}    -- Todos los módulos en Wikipedia comienzan definiendo una variable 
                -- que tendrá todas las funciones accesibles externamente 
                -- Estas variables pueden tener el nombre que desee 
function p.hola(frame)  -- Añadir una función al objeto "p" 
                        -- Estas funciones se podrán invocar en otras páginas vía #invoke 
                        -- "frame" contiene los datos que Wikipedia envía a esta función 
    return '¡Hola mundo!' -- Sale de la función con la información a devolver a la Wikipedia 
end          -- Final de la función "hola" 
 
return p     -- Todos los módulos terminan retornando a la Wikipedia la variable 
             -- que contiene las funciones

Puede ejecutar en una página wiki, por ejemplo en la misma página de discusión de pruebas:

{{#invoke:mi_módulo|hola}}

Esto invoca el módulo mi_módulo, o como lo haya llamado, y la función exportada "hola" de este módulo. Sustituye la invocación por el texto devuelto por la función. Normalmente las invocaciones se harán desde una plantilla.

Estructuras de control[editar]

si ... entonces... si ... entonces... si no ... si ... entonces... o si ... si no ...
if color == 'negro' then
    cssColor = '#000'
end
if color == 'negro' then
    cssColor = '#000'
else
    cssColor = color
end
if color == 'negro' then
    cssColor = '#000'
elseif color == 'blanco' then
    cssColor = '#fff'
else
    cssColor = color
end

Los dos signos == comprueban la igualdad. Un solo signo = es para asignar.

Bucle for:

f = 1 -- asigna el valor inicial
for i = 1, 5 do
    f = f * i
end
return 'El factorial de 5 es ' .. f

Los dos guiones - son para añadir comentarios. Los dos puntos seguidos .. son para concatenar.

Tipos de datos[editar]

  • Cadena (string), entre comillas simples ('...') o dobles ("..."). Cuidado con los apostrofos rectos.
  • Numérico, con punto decimal.
  • Booledana: "true" o "false" (verdadero o falso)
  • "Nil" (nulo)
  • Tabla
  • "Function" (función)

Operadores lógicos[editar]

and: Los dos son verdadesros or: Uno, el otro o ambos not: Lo que sigue es falso
if tostada and mantequilla then
    return 'desayuno'
end
if pechuga or muslo then
    return 'almuerzo'
end
if not hambre then
    return 'ayunar'
end

Funciones[editar]

Declaración de funciones:

sin argumentos con argumentos función no local para llamar fuera del módulo
local function getColour()
    return 'azul'
end
local function plural(mundo)
    return mundo .. 's'
end
local p = {}
function p.hola()
    return '¡Hola mundo!'
end
return p

Para llamar a la función:

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

Variables[editar]

Hay tres tipos de variables: variables globales, variables locales y tablas. Una variable se considera global a no ser que se declare explícitamente con la clave local. Una variable local es visible dentro del bloque donde ha sido declarada. Una variable declarada sin asignación tiene valor nil (nulo).


x = 10           -- variable global
do               -- nuevo bloque
    local x = x  -- nueva x asignada el valor de la anterior
    x = x + 1    -- 11
end              -- cierra el bloque y sus variables locales
return x         -- 10, la global
local x
if ready then
    x = 've allí'
end
-- x es 've allí' si
-- ready, si no nil (nulo)

Creación de una tabla:

números = {uno = 1, dos = 2, tres = 3}

Acceso a un elemento de la tabla:

return números.dos    -- devuelve 2
return números['dos'] -- también devuelve 2

Tabla numerada:

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

Iteración de elementos de la tabla:

pairs: par clave/valor en orden aleatorio ipairs: claves numéricas en orden ascendente
for nombre, número in pairs(números) do
    ...
end
for index, bread in ipairs(africanFlatbreads) do
    ...
end

Cadenas[editar]

#, longitud sub, substring
s = 'hola'
return #s  -- devuelve 4
s = 'hola'
return s:sub(2,3)  -- devuelve 'ol'
return s:sub(2)    -- devuelve 'ola'
return s:sub(-2)   -- devuelve 'la'

Introducción para los programadores[editar]

Léxico[editar]

  • El formato de comentarios recuerda SQL
    -- comentario en una única línea
    --[[
    comentario largo
    --]]
  • Los saltos de línea son ignorados.
  • Los puntos y comas para terminar las declaraciones son opcionales y no son recomendados.

Tipos de datos[editar]

  • Nil (nulo)
  • Numèricos, un único formato de punto flotante de precisión doble.
  • Strings (cadenas), 8-bit
  • Booledanos
  • Funciones
    • Valores de primera clase.
    • Devuelve valores múltiples.
    • Los valores de retorno múltiples no están ligados a un tipo de dato.
    • Sintáxis anónima
x = function()
    ...
end
  • Tablas
    • Implementadas como hashtable
    • Usadas para OOP, com Javascript
    • Sintáxis literal: {nombre = valor} o {a, b, c}
    • Acceso con foo.bar o foo['bar']

Operadores[editar]

  • No igual: ~= (en lugar de !=)
  • Concatenación: ..
  • Longitud: #
  • Lógicos: and, or, not
  • Exponencial: ^
  • Con el significado habitual: <, >, <=, >=, ==, +, -, *, /, %
  • Operadores omitidos:
  • Asignación. Como en BASIC, la asignación es una declaración completa, no una expresión.
Asignación múltiple Asignación con declaración de variable local
a, b = c, d
a, b = foo()
local a, b = c, d
local a = b, c = d -- así no!

Estructuras de control[editar]

  • Bloque explícito
do
    ...
end
  • Bucles
Bucle con condición inicial Bucle con condición final
while cond do
    ...
end
repeat
    ...
until cond
For numèrico For genèrico
for i = start, stop do
    ...
end
for i in iterator
    ...
end
La variable de índice es local del bucle
  • If
if cond then
    ...
elseif cond then
    ...
else
    ...
end

Datos[editar]

  • Variables
    • Ámbito léxico, casi idéntico a JavaScript.
    • Una variable no determinada es idéntica a una variable nil.
    • Ninguna sintaxis especial para suprimir, simplemente x = nil.
    • El acceso a variables no definidas no genera errores.
  • Objetos
    • Hechos de tablas utilizando una variedad de sintaxis, similar a JavaScript.
    • Variables de elementos privados implementadas con ámbito léxico, como en JavaScript.
    • Punto para métodos estáticos: obj.func ()
    • Dos puntos para métodos no estáticos: obj: func ()
    • Ejemplo de estilo de construcción de una función:
function newObj()
    local private = 1
    local obj = {}
    function obj:getPrivate()
        return private
    end
    return obj
end

Interfaz de MediaWiki[editar]

Todo el código Lua está en el espacio de nombres Módulo. Hay disponible un editor de código Ace.

Invocación:

{{ #invoke: nombre_módulo | nombre_función | arg1 | arg2 | nombre1 = valor1 }}

Las instancias de invocación son aisladas, los globales definidos en una no están disponibles en otra.

Un módulo es un bloque Lua que devuelve una tabla de exportación. Se proporciona require () y librería package. La función de exportación devuelve una cadena de texto wiki, convirtiendo los valores que no son string. Los valores múltiples de retorno son concatenados.

Métodos frame:

  • args:
local nombre1 = frame.args.nombre1
  • argumentPairs():
local t = {}
for nombre, valor in frame:argumentPairs() do
    t[name] = value
end
  • getParent(): Proporciona acceso al frame superior, por ejemplo los argumentos de la plantilla que llamó #invoke
  • Preproceso de texto wiki
frame:preprocess('{{plantilla}}')
  • Invocación estructurada de plantilla
frame:expandTemplate{
    title = 'plantilla',
    args = {foo = foo}}
Los argumentos son siempre expandidos. No es necesario construir preprocesar las entradas de los argumentos.

Posibilidades en el futuro:

  • Invocación interwiki de módulos.
  • Otros lenguajes diferentes a Lua.
  • Funciones de fecha y hora.
  • Acceso directo a funciones parser y variables como {{PAGENAME}}, {{#ifexists:}}.

Para saber más[editar]