Museo8bits: Página creada con «Este módulo provee un procesamiento fácil a los argumentos que pasan de `#invoke`. Es un metamódulo, pensado para s…»

2021-10-24T12:23:26Z

Página creada con «Este módulo provee un procesamiento fácil a los argumentos que pasan de <code>#invoke</code>. Es un metamódulo, pensado para s…»

Página nueva

Este módulo provee un procesamiento fácil a los argumentos que pasan de <code>#invoke</code>. Es un [[:Categoría:Wikipedia:Metamódulos Lua|metamódulo]], pensado para ser usado por otros módulos, y no debería ser llamado directamente desde <code>#invoke</code>. Entre sus características se incluyen:
*Eliminar espacios en blanco al principio y final de los valores (no implementado todavía)
*Eliminar parámetros vacíos (no implementado todavía)
*Los argumentos pueden ser pasados por el marco actual y el marco padre a la vez (no implementado todavía)
*Los argumentos pueden ser pasados por otro módulo Lua o desde la [[depurador|consola de depuración]].
*La mayoría de las características pueden ser personalizadas.

==Uso básico==
Para empezar, se debe cargar el módulo. Contiene una función, llamada <code>obtenerArgumentos</code>.

<syntaxhighlight lang="lua">
local dameArgs = require('Módulo:Argumentos').obtenerArgumentos
</syntaxhighlight>

En el escenario más básico, se puede usar obtenerArgumentos dentro de la función principal (usualmente <code>main</code>).
La variable <code>args</code> es una tabla que contiene los argumentos de #invoke.

<syntaxhighlight lang="lua">
local dameArgs = require('Módulo:Argumentos').obtenerArgumentos
local p = {}

function p.main(marco)
local args = dameArgs(marco)
-- El código principal del módulo vas acá
end

return p
</syntaxhighlight>

Sin embargo, se recomienda usar una función solo para procesar los argumentos de #invoke. Esto significa que si se llama al módulo desde otro módulo Lua, no es necesario tener un objeto marco disponible, mejorando el rendimiento.

<syntaxhighlight lang="lua">
local dameArgs = require('Módulo:Argumentos').obtenerArgumentos
local p = {}

function p.main(marco)
local args = dameArgs(marco)
return p._main(args)
end

function p._main(args)
-- El código principal del módulo vas acá
end

return p
</syntaxhighlight>

Si se quiere múltiples funciones que usen los argumentos, y que también sean accesibles desde #invoke, puede usarse una función envolvente.

<syntaxhighlight lang="lua">
local dameArgs = require('Módulo:Argumentos').obtenerArgumentos

local function hazFuncInvoke(fn)
return function (marco)
local args = dameArgs(marco)
return p[fn](args)
end
end

local p = {}

p.func1 = hazFuncInvoke('_func1')

function p._func1(args)
-- El código de la primera función va acá
end

p.func2 = hazFuncInvoke('_func2')

function p._func2(args)
-- El código de la segunda función va acá
end

return p
</syntaxhighlight>

=== Opciones ===

Las siguientes opciones están disponible, y son explicadas en las secciones de abajo.

<syntaxhighlight lang="lua">
local args = dameArgs(marco, {
limpiarEspacios = false,
removerVacios = false,
fnValores = function (clave, valor)
-- Código para procesar un argumento
end,
soloMarco = true,
soloPadre = true,
padrePrimero = true,
envolventes = {
'Plantilla:Una plantilla envolvente',
'Plantilla:Otra plantilla envolvente'
},
soloLectura = true,
noSobreescribir = true
})
</syntaxhighlight>

=== Eliminar espacios y vacios ===

<syntaxhighlight lang="lua">
local args = dameArgs(marco, {
limpiarEspacios = false,
removerVacios = false
})
</syntaxhighlight>

=== Personalización del formato de los argumentos ===
Algunas veces se desea remover algunos argumentos en blanco pero no otros, o tal vez poner todos los argumentos posicionales en minúscula. Para hacer cosas como estas, se usa la opción <code>fnValores</code>. La entrada a esta opción debe ser una función que toma dos parámetros, <code>clave</code> and <code>value</code>, y devuelve un valor sencillo. Este valor es lo que se obtiene cuando acceda al campo <code>clave</code> en la tabla de <code>args</code>

Ejemplo 1: esta función preserva los espacio en blanco para el primer argumento posicional, pero los elimina de los otros argumentos, y los elimina si quedan vacíos:
<syntaxhighlight lang="lua">
local args = dameArgs(marco, {
fnValores = function (clave, valor)
if 1 == clave then
return valor
elseif valor then
valor = mw.text.trim(valor) -- Elimina los espacios al comienzo y final del valor
if '' ~= valor then -- Si el valor no quedó vacío
return valor -- Lo devuelve
end
end
return nil -- En otros casos, devuelve el valor nulo (es decir, no incluir el valor)
end
})
</syntaxhighlight>

Ejemplo 2: esta función elimina los argumentos vacíos y convierte todos los argumentos a minúsculas, pero no elimina los espacios del comienzo y final de los parámetros posicionales.
<syntaxhighlight lang="lua">
local args = dameArgs(marco, {
fnValores = function (clave, valor)
if not valor then
return nil
end
value = mw.ustring.lower(valor)
if mw.ustring.find(valor, '%S') then
return valor
end
return nil
end
})
</syntaxhighlight>

Nota: las funciones de arriba fallarán si se les pasa una entrada que no sea de tipo <code>string</code> or <code>nil</code>. Esto puede suceder si se usa la función <code>dametArgs</code> en la función principal del módulo, y esa función es llamada desde otro módulo Lua. En este caso, es necesario comprobar el tipo de la entrada. Esto no es un problema cuando se usa una función específicamente para obtener los argumentos de #invoke; por ejemplo, cuando se usa una función para ese caso (usualmente <code>p.main</code>) y otra ser usada por otros módulos (usualmente <code>p._main</code>).


También, es importante destacar que la función <code>fnValores</code> es llamada aproximadamente cada vez que se pide un argumento de la tabla <code>args</code>. Por lo tanto, si se quiere mejorar el rendimiento debería verificarse no estar haciando nada ineficiente en ese código.

=== Marcos y marcos padre ===
Los argumentos de la tabla <code>args</code> pueden ser pasados desde el marco actual o del marco padre a la vez. Para enteder qué significa esto, es más fácil dar un ejemplo. Digamos que tenemos un módulo llamado <code>Módulo:EjemploArgs</code>, qu eimprime los primeros dos parámetros posicionales que se le pasen:

=== Envolventes ===
La opción ''envolventes'' se usa para indicar un número limitado de plantillas que funcionan como envolentes; es decir, cuyo único propósito es llamar al módulo. Si el módulo detecta que es llamado desde una de estas plantillas, solo comprobará los argumentos del marco padre; de lo contrario solo lo hará con el marco pasado a <code>dameArgs</code>. Esto le permite al módulo ser llamado tanto desde #invoke como desde una envolvente sin la pérdida de rendimiento asociada a tener que comprobar ambos marcos (el actual y el padre) por cada argumento.



=== Escribiendo en la tabla args ===


=== Etiquetas ref ===


=== Limitaciones conocidas ===


<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||
[[Categoría:Metamódulos Lua]]
}}</includeonly>

Módulo:Argumentos/doc - Historial de revisiones

Museo8bits: Página creada con «Este módulo provee un procesamiento fácil a los argumentos que pasan de #invoke. Es un metamódulo, pensado para s…»

Museo8bits: Página creada con «Este módulo provee un procesamiento fácil a los argumentos que pasan de `#invoke`. Es un metamódulo, pensado para s…»