Fandom Developers Wiki
Advertisement

Esta página, o partes de ella, siguen sin traducir. Por favor traduzcala al lenguaje apropriado (español).

Esta página cubre algunos de los conceptos básicos absolutos para desarrollar una plantilla sencilla en Lua.

Basics[]

Main article: Basics

Antes de empezar con las plantillas Lua, es importante leer y conocer cómo se usan las plantillas wikitext normales, y preferiblemente leer/aprender sobre Lua en sitios como Wikibooks así como revisar el manual de referencia Lua.

Espacio de trabajo[]

Las plantillas Lua se almacenan en el espacio de nombres Módulo, y todo el trabajo siempre debe ser guardado ahí. Por ejemplo, un módulo llamado holamundo se guardaría en Módulo:Holamundo.

Creando un módulo[]

Un módulo siempre debe contener una tabla y una línea que contenga un "retorno" para dicha tabla, a menos que sea un metamódulo (ver más abajo).

--Tabla
local p = {}
-- el código va aquí
return p

Para que un módulo pueda ser invocado (o utilizado en una página), necesita tener una función. Sin embargo, esta función debe formar parte de la tabla principal (p. ej. invocable):

--Tabla
local invocable = {}

--puede ser invocada
function invocable.saludar(frame)
   return "Larga vida y próspera"
end

--no se puede invocar
function preguntarnombre(frame)
   return "¿Cómo te llamas?"
end
return invocable

Tiempo de ejecución[]

Los módulos Lua utilizados sólo pueden ejecutarse durante un máximo de 7 segundos. Esto significa que los módulos dentro de una página no pueden tardar más de 7 segundos en ejecutarse, o se producirá un error.

Copiando módulos a otra wiki[]

Los módulos alojados aquí se pueden usar en otras wiki, pero esto puede requerir algunos pasos:

  1. Copie el módulo en su wiki, por ejemplo Módulo:Enlaces
  2. Copie todos los módulos de los que depende el Módulo:Enlaces a su wiki. Esto es un poco complicado porque Fandom utiliza una versión antigua de Scribunto. Pero estos pasos deberían ayudar:
    1. Abra la página del módulo y busque secciones que contengan texto como require("texto"), por ejemplo: en el módulo enlaces "texto" es igual a "Dev:Arguments".
    2. Busque un módulo en dev.fandom o en cualquier otra wiki, p. ej. Módulo:Argumentos.
    3. Copie este Módulo:Argumentos a su wiki.
    4. Sustituya todas las menciones de require("Dev:") con require("Módulo:"), p. ej. require("Módulo:Argumentos")
  3. Repita el paso dos, cada vez que se encuentre un require("") en el módulo copiado.

Usando entradas (parámetros)[]

Las entradas (o parámetros de plantillas) se pueden proporcionar a un módulo durante la invocación.

Sintaxis[]

{{#invoke:nombredemodulo|nombredefuncion|entrada1|entrada2|entrada3|...}}

Una vez ejecutado el código anterior, una tabla (llamada frame) es creada conteniendo todas esas entradas, y es pasada a una función, y almacenada en una subtabla llamada args (p. ej. frame.args). Por ejemplo, utilizando la invocación siguiente se hará uso del módulo:

{{#invoke:invocable|saludar|john}}
{{#invoke:invocable|saludar|nombre=john}}
--Módulo:Invocable
--Tabla
local invocable = {}

function invocable.saludar(frame)
   local nombre = frame.args[1] or frame.args["nombre"]

   return "Larga vida y próspera " ..nombre
end

return invocable
Resultado
Larga vida y próspera john

Explicación: Args es una lista que contiene todos los parámetros, args[1] se refiere al primer valor, p. ej.: john, args["nombre"] accede a un parámetro denominado "nombre".

Accediendo a entradas de plantillas[]

El código en el módulo anterior, si está incluido en una plantilla de wikitexto, no puede acceder a los parámetros pasados a la plantilla. Se puede acceder a dichos argumentos recuperando primero el frame padre usando frame:getParent(), y luego accediendo a la subtabla frame:getParent().args:

Plantilla:saludar
{{#invoke:invocable|saludar}}
Módulo:invocable
--Tabla
local invocable = {}

function invocable.saludar(frame)
   local parent = frame:getParent()
   local nombre = parent.args[1]
   local nombre2 = parent.args[2] or ""

   return "Larga vida y próspera :" ..nombre ..' '..nombre2
end

return invocable
Uso
{{saludar|Jack}}
Resultado
Larga vida y próspera :Jack 
Uso
{{saludar|Jack|Jill}}
Resultado
Larga vida y próspera :Jack Jill
Ejemplo Parámetro Plantilla Módulo Resultado
{{saludar|john}} 1 {{{1}}} frame:getParent().args[1] john
{{saludar|nombre=Spock}} nombre {{{nombre}}}} frame:getParent().args["nombre"] Spock
{{#invoke:invocable|saludar|john}} 1 frame.args[1] john
{{#invoke:invocable|saludar|nombre=Worf}} nombre frame.args["nombre"] Worf
{{#invoke:invocable|saludar|jack|jill}} 1,2 frame.args[1], frame.args[2] Jack , Jill

Errores de secuencia de comandos[]

Siempre que un módulo no funciona correctamente provoca un error de secuencia de comandos en una página. Wikipedia mantiene una buena explicación de los errores de secuencia de comandos.

Avanzado[]

Una ventaja de Lua es que permite utilizar módulos y tablas externos creados por otros. Esto reduce la necesidad de reinventar la rueda y se puede dedicar más tiempo a crear nuevas soluciones.

Usando otros módulos[]

Para utilizar bibliotecas o módulos es necesario importar esa biblioteca. Esto se hace utilizando el método require:

--Módulo:Libraries
local biblioteca = {}

function biblioteca.saludar(frame)
   local invocable = require("Módulo:invocable")

   return invocable.saludar(frame)
end

return biblioteca
{{#invoke:biblioteca|saludar|Zeus}}
Resultado
Larga vida y próspera Zeus

Nota: La sintaxis es sensible a las mayúsculas y minúsculas por lo que "Dev" es diferente de "dev".

Metamódulos[]

Estos son módulos que no están destinados a usarse en una página (p. ej. {{#invoke), y no tienen necesariamente funciones que puedan utilizarse en una página.

Usando tablas externas[]

Una tabla externa se puede recuperar de la misma manera que un módulo externo, excepto que hay un método adicional (mw.loadData) que la carga una vez por página, lo que la hace más eficiente.

--Módulo:tablas
local tablas = {'comida','jardín','reliquia'}
return tablas
Uso
--Módulo:mostrarobjetos
local p = {}

function p.mostrar(frame)
   local objetos = require("Módulo:tablas")
   --usando loadData
   local objetos2 = mw.loadData("Módulo:tablas")

   return objetos[1] ..' & ' objetos2[2]
end

return p
{{#invoke:mostrarobjetos|mostrar}}
Resultado
comida & jardín

Módulos globales[]

Main article: Global modules

Los módulos almacenados en dev.fandom.com se denominan módulos globales. Funcionan de manera similar a los módulos almacenados en una wiki pero se puede acceder a ellos desde cualquier módulo Lua de otra wiki (p. ej. food.fandom.com). La diferencia radica únicamente en la sintaxis (usa "Dev" en lugar de "Módulo") utilizada para obtener los módulos:

local global_invocable = require("Dev:Invocable")
local global_Tables = mw.loadData("Dev:Tables")

Herramientas[]

Hay un montón de herramientas útiles que pueden ayudar a crear módulos:

Editor de código[]

El editor de código (o editor ace): este es el editor por defecto que se puede desactivar según sea necesario.

El editor Ace, en particular, viene con un par de funciones ocultas, como atajos de teclado y macros.[1]

Atajos de teclado[]

A continuación se muestra una breve lista de algunos atajos útiles:

Windows/Linux Mac Acción
⎇ Alt + ⇧ Shift +  ⌘ Command + ⌥ Option +  Copia líneas hacia abajo
⎇ Alt + ⇧ Shift +  ⌘ Command + ⌥ Option +  Copia líneas hacia arriba
⎇ Alt +  ⌥ Option +  Mueve líneas hacia abajo
⎇ Alt +  ⌥ Option +  Mueve líneas hacia arriba
⎇ Alt + ⌦ Delete Ctrl + K Elimina hasta el final de la línea
⎇ Alt + ← Backspace ⌘ Command + ← Backspace Elimina al inicio de la línea
Ctrl + ← Backspace ⌥ Option + ← Backspace, Ctrl + ⌥ Option + ← Backspace Elimina la palabra de la izquierda
Ctrl + ⌦ Delete ⌥ Option + ⌦ Delete Elimina la palabra de la derecha
--- Ctrl + O Linea divisoria
Windows/Linux Mac Acción
Ctrl + ⇧ Shift + E ⌘ Command + ⇧ Shift + E Repetición de macros
Ctrl + ⎇ Alt + E --- Grabación de macros

Resaltado y comprobación de sintaxis[]

El editor de código interactivo siempre resalta los errores de sintaxis y, algunas veces, ofrece información útil para corregirlos.

Consola de depuración[]

Main article: Debug console

Esta es una consola o terminal que facilita las pruebas de código.

Ver también[]

Referencias[]

Advertisement