Módulo: Argumentos

Este módulo proporciona un procesamiento sencillo de los argumentos pasados ​​desde #invoke. Es un metamódulo, destinado a ser utilizado por otros módulos, y no se debe llamar directamente desde #invoke. Entre sus características se incluyen:

• Fácil recorte de argumentos y eliminación de argumentos en blanco.
• Los argumentos se pueden pasar tanto por el marco actual como por el marco principal al mismo tiempo. (Más detalles a continuación).
• Los argumentos se pueden pasar directamente desde otro módulo Lua o desde la consola de depuración.
• Los argumentos se obtienen según sea necesario, lo que puede ayudar a evitar (algunos) problemas con las etiquetas ref.
• La mayoría de las funciones se pueden personalizar.

Contenido

• 1 Uso básico
  • Opciones 1.1
  • 1.2 Recorte y eliminación de espacios en blanco
  • 1.3 Formato personalizado de argumentos
  • 1.4 Marcos y marcos principales
  • 1.5 envoltorios
  • 1.6 Escribir en la tabla de argumentos
  • 1.7 Etiquetas de referencia
  • 1.8 Limitaciones conocidas

Uso basico

Primero, necesitas cargar el módulo. Contiene una función, llamada getArgs.

getArgs local = require ('Módulo: Argumentos'). getArgs

En el escenario más básico, puede usar getArgs dentro de su función principal. La variable args es una tabla que contiene los argumentos de #invoke. (Consulte los detalles a continuación).

local getArgs = require ('Módulo: Argumentos'). getArgs local p = {} function p.main (frame) local args = getArgs (frame) - El código del módulo principal va aquí. fin volver p

Sin embargo, la práctica recomendada es utilizar una función solo para procesar argumentos de #invoke. Esto significa que si alguien llama a su módulo desde otro módulo Lua, no es necesario que tenga un objeto de marco disponible, lo que mejora el rendimiento.

local getArgs = require ('Módulo: Argumentos'). getArgs local p = {} function p.main (frame) local args = getArgs (frame) return p._main (args) end function p._main (args) - Main el código del módulo va aquí. fin volver p

Si desea que varias funciones usen los argumentos, y también desea que sean accesibles desde #invoke, puede usar una función contenedora.

local getArgs = require ('Módulo: Argumentos'). getArgs función local makeInvokeFunc (funcName) return function (frame) local args = getArgs (frame) return p [funcName] (args) end end local p = {} p.func1 = makeInvokeFunc ('_ func1') function p._func1 (args) - Aquí va el código de la primera función. end p.func2 = makeInvokeFunc ('_ func2') function p._func2 (args) - El código para la segunda función va aquí. fin volver p

de pago

Las siguientes opciones están disponibles. Se explican en las secciones siguientes.

local args = getArgs (frame, {trim = false, removeBlanks = false, valueFunc = function (key, value) - Código para procesar un argumento end, frameOnly = true, parentOnly = true, parentFirst = true, wrappers = {'Plantilla : Una plantilla contenedora ',' Plantilla: otra plantilla contenedora '}, readOnly = true, noOverwrite = true})

Recortar y quitar espacios en blanco

Los argumentos en blanco a menudo hacen tropezar a los programadores nuevos en la conversión de plantillas de página de Mediaweb a Lua. En la sintaxis de plantilla, las cadenas en blanco y las cadenas que constan solo de espacios en blanco se consideran falsas. Sin embargo, en Lua, las cadenas en blanco y las cadenas que constan de espacios en blanco se consideran verdaderas. Esto significa que si no presta atención a tales argumentos cuando escribe sus módulos Lua, puede tratar algo como verdadero que en realidad debería tratarse como falso. Para evitar esto, de forma predeterminada, este módulo elimina todos los argumentos en blanco.

De manera similar, los espacios en blanco pueden causar problemas al tratar con argumentos posicionales. Aunque los espacios en blanco se recortan para los argumentos con nombre que provienen de #invoke, se conservan para los argumentos posicionales. La mayoría de las veces no se desea este espacio en blanco adicional, por lo que este módulo lo recorta de forma predeterminada.

Sin embargo, a veces desea utilizar argumentos en blanco como entrada y, a veces, desea mantener espacios en blanco adicionales. Esto puede ser necesario para convertir algunas plantillas exactamente como fueron escritas. Si desea hacer esto, puede establecer los argumentos trim y removeBlanks en falso.

argumentos locales = getArgs (frame, {trim = false, removeBlanks = false})

Formato personalizado de argumentos

A veces desea eliminar algunos argumentos en blanco pero no otros, o quizás desee poner todos los argumentos posicionales en minúsculas. Para hacer cosas como esta, puede usar la opción valueFunc. La entrada a esta opción debe ser una función que tome dos parámetros, clave y valor, y devuelva un solo valor. Este valor es lo que obtendrá cuando acceda a la clave de campo en la tabla de argumentos.

Ejemplo 1: esta función conserva los espacios en blanco para el primer argumento posicional, pero recorta todos los demás argumentos y elimina todos los demás argumentos en blanco.

local args = getArgs (frame, {valueFunc = function (key, value) if key == 1 then return value elseif value then value = mw.text.trim (value) if value ~ = '' then return value end end return nil fin })

Ejemplo 2: esta función elimina los argumentos en blanco y convierte todos los argumentos a minúsculas, pero no recorta los espacios en blanco de los parámetros posicionales.

local args = getArgs (frame, {valueFunc = function (key, value) if no value, return nil end value = mw.ustring.lower (value) if mw.ustring.find (value, '% S') then return value end return nil end})

Nota: las funciones anteriores fallarán si se pasa una entrada que no sea de tipo cadena o nil. Este podría ser el caso si usa la función getArgs en la función principal de su módulo, y esa función es llamada por otro módulo Lua. En este caso, deberá verificar el tipo de su entrada. Esto no es un problema si está usando una función especialmente para argumentos de #invoke (es decir, tiene las funciones p.main y p._main, o algo similar).

Ejemplos 1 y 2 con verificación de tipo Ejemplo 1:

local args = getArgs (frame, {valueFunc = function (key, value) if key == 1 then return value elseif type (value) == 'string' then value = mw.text.trim (value) if value ~ = ' 'luego devuelve el valor si no devuelve nil end else devuelve el valor end end})

Ejemplo 2:

local args = getArgs (frame, {valueFunc = function (key, value) if type (value) == 'string' then value = mw.ustring.lower (value) if mw.ustring.find (value, '% S' ) luego devuelve el valor si no devuelve nil end else devuelve el valor end end})

Además, tenga en cuenta que la función valueFunc se llama más o menos cada vez que se solicita un argumento de la tabla de argumentos, por lo que si le importa el rendimiento, debe asegurarse de no hacer nada ineficiente con su código.

Marcos y marcos principales

Los argumentos en la tabla de argumentos se pueden pasar desde el marco actual o desde su marco padre al mismo tiempo. Para comprender lo que esto significa, lo más fácil es dar un ejemplo. Digamos que tenemos un módulo llamado Module: ExampleArgs. Este módulo imprime los dos primeros argumentos posicionales que se le pasa.

Módulo: código ExampleArgs

local getArgs = require ('Module: Arguments'). getArgs local p = {} function p.main (frame) local args = getArgs (frame) return p._main (args) end function p._main (args) local first = args [1] o '' local second = args [2] o '' return first .. '' .. second end return p

Module: ExampleArgs es llamado por Template: ExampleArgs, que contiene el código {{#invoke: ExampleArgs | main | firstInvokeArg}}. Esto produce el resultado "firstInvokeArg".

Ahora bien, si tuviéramos que llamar a Template: ExampleArgs, sucedería lo siguiente:

Hay tres opciones que puede configurar para cambiar este comportamiento: frameOnly, parentOnly y parentFirst. Si establece frameOnly, solo se aceptarán los argumentos pasados ​​desde el marco actual; si establece parentOnly, solo se aceptarán los argumentos pasados ​​desde el marco principal; y si establece parentFirst, los argumentos se pasarán tanto del marco actual como del marco principal, pero el marco principal tendrá prioridad sobre el marco actual. Estos son los resultados en términos de Template: ExampleArgs:

solo marco parentOnly parentFirst

:

1. Si configura las opciones frameOnly y parentOnly, el módulo no obtendrá ningún argumento de #invoke. Probablemente esto no sea lo que quieres.
2. En algunas situaciones, un marco padre puede no estar disponible, por ejemplo, si getArgs se pasa el marco padre en lugar del marco actual. En este caso, solo se usarán los argumentos del marco (a menos que se establezca parentOnly, en cuyo caso no se usarán argumentos) y las opciones parentFirst y frameOnly no tendrán ningún efecto.

Envoltorios

La opción de envoltorios se utiliza para especificar un número limitado de plantillas como plantillas de envoltorio, es decir, plantillas cuyo único propósito es llamar a un módulo. Si el módulo detecta que está siendo llamado desde una plantilla contenedora, solo buscará argumentos en el marco padre; de lo contrario, solo buscará argumentos en el marco pasado a getArgs. Esto permite que los módulos sean llamados por #invoke o mediante una plantilla contenedora sin la pérdida de rendimiento asociada con tener que verificar tanto el marco como el marco principal para cada búsqueda de argumento.

Los envoltorios se pueden especificar como una cadena o como una matriz de cadenas.

argumentos locales = getArgs (marco, {envoltorios = 'Plantilla: plantilla envoltorio'})

local args = getArgs (frame, {wrappers = {'Template: Wrapper 1', 'Template: Wrapper 2', - Aquí se puede agregar cualquier número de plantillas de wrapper.}})

:

1. El módulo detectará automáticamente si se está llamando desde la subpágina / sandbox de una plantilla contenedora, por lo que no es necesario especificar páginas de sandbox explícitamente.
2. La opción de envoltorios cambia efectivamente el valor predeterminado de las opciones frameOnly y parentOnly. Si, por ejemplo, parentOnly se estableciera explícitamente en falso con envoltorios configurados, las llamadas a través de plantillas de envoltura darían como resultado la carga de los argumentos padre y de marco, aunque las llamadas que no se realizaran a través de plantillas de envoltura darían como resultado que solo se cargaran los argumentos de marco.
3. Si la opción de envoltorios está configurada y no hay ningún marco padre disponible, el módulo siempre obtendrá los argumentos del marco pasado a getArgs.

Escribiendo en la tabla de argumentos

A veces puede resultar útil escribir nuevos valores en la tabla de argumentos. Esto es posible con la configuración predeterminada de este módulo. (Sin embargo, tenga en cuenta que generalmente es mejor estilo de codificación crear una nueva tabla con sus nuevos valores y copiar argumentos de la tabla de argumentos según sea necesario).

args.foo = 'algún valor'

Es posible modificar este comportamiento con las opciones readOnly y noOverwrite. Si readOnly está configurado, entonces no es posible escribir ningún valor en la tabla de argumentos. Si noOverwrite está configurado, entonces es posible agregar nuevos valores a la tabla, pero no es posible agregar un valor si sobrescribirá cualquier argumento que se pase de #invoke.

Etiquetas de referencia

Este módulo utiliza metatablas para obtener argumentos de #invoke. Esto permite el acceso tanto a los argumentos del marco como a los argumentos del marco principal sin usar la función pares (). Esto puede ayudar si su módulo puede pasar etiquetas ref como entrada.

Tan pronto como se accede a las etiquetas de referencia desde Lua, el software de la página Mediaweb las procesa y la referencia aparecerá en la lista de referencias en la parte inferior del artículo. Si su módulo procede a omitir la etiqueta de referencia de la salida, terminará con una referencia fantasma, una referencia que aparece en la lista de referencias, pero ningún número que la vincule. Esto ha sido un problema con los módulos que usan pares () para detectar si se deben usar los argumentos del marco o del marco principal, ya que esos módulos procesan automáticamente todos los argumentos disponibles.

Este módulo resuelve este problema al permitir el acceso tanto a los argumentos del marco como al marco principal, mientras que solo obtiene esos argumentos cuando es necesario. Sin embargo, el problema seguirá ocurriendo si usa pares (args) en otras partes de su módulo.

Limitaciones conocidas

El uso de metatablas también tiene sus desventajas. La mayoría de las herramientas de tabla normales de Lua no funcionarán correctamente en la tabla de argumentos, incluido el operador #, la función next () y las funciones de la biblioteca de tablas. Si usar estos es importante para su módulo, debe usar su propia función de procesamiento de argumentos en lugar de este módulo.

- Este módulo proporciona un procesamiento sencillo de los argumentos pasados ​​a Scribunto desde - #invoke. Está diseñado para que lo utilicen otros módulos Lua y no se debe llamar directamente desde #invoke. local libraryUtil = require ('libraryUtil') local checkType = libraryUtil.checkType argumentos locales = {} - Genera cuatro funciones tidyVal diferentes, de modo que no tengamos que marcar las - opciones cada vez que lo llamemos. función local tidyValDefault (key, val) if type (val) == 'string' then val = val: match ('^% s * (.-)% s * $') if val == '' luego devuelve nil else return val end else return val end end función local tidyValTrimOnly (key, val) if type (val) == 'string' then return val: match ('^% s * (.-)% s * $') else return val end end función local tidyValRemoveBlanksOnly (key, val) if type (val) == 'string' then if val: find ('% S') then return val else return nil end else return val end end función local tidyValNoChange (key, val ) return val end función local coincide con Título (dado, título) local tp = tipo (dado) return (tp == 'cadena' o tp == 'número') y mw.title.new (dado) .prefixedText == fin del título translate_mt local = {__index = function (t, k) return k end} argumentos de la función.getArgs (frame, options) checkType ('getArgs', 1, frame, 'table', true) checkType ('getArgs', 2, options , 'tabla', verdadero) marco = marco o {} opciones = opciones o {} - [[- Configurar traducción de argumentos. -]] options.translate = options.translate o {} if getmetatable (options.translate) == nil then setmetatable (options.translate, translate_mt) end if options.backtranslate == nil then options.backtranslate = {} para k , v en pares (options.translate) do options.backtranslate [v] = k end end if options.backtranslate y getmetatable (options.backtranslate) == nil then setmetatable (options.backtranslate, {__index = function (t, k) if options.translate [k] ~ = k entonces devuelve nil else return k end end}) end - [[- Obtiene las tablas de argumentos. Si se nos pasó un objeto de marco válido, obtenemos los argumentos del marco - (fargs) y los argumentos del marco padre (pargs), dependiendo - del conjunto de opciones y de la disponibilidad del marco padre. Si no se nos pasó un objeto de marco válido, se nos llama desde otro módulo de Lua, o desde la consola de depuración, así que suponga que se nos pasó una tabla de argumentos, directamente y asígnelo a una nueva variable. (luaArgs). -]] local fargs, pargs, luaArgs if type (frame.args) == 'table' and type (frame.getParent) == 'function' then if options.wrappers then - [[- La opción wrappers hace Módulo: Los argumentos buscan argumentos en, ya sea en la tabla de argumentos del marco o en la tabla de argumentos principales, pero no en ambos. Esto significa que los usuarios pueden usar la sintaxis #invoke, o una plantilla contenedora sin la pérdida de rendimiento asociada, con la búsqueda de argumentos tanto en el marco como en el marco principal. - Módulo: Los argumentos buscarán argumentos en el marco principal, si encuentra el título del marco principal en options.wrapper; - de lo contrario, buscará argumentos en el objeto de marco pasado - a getArgs. -]] local parent = frame: getParent () si no es padre, entonces fargs = frame.args else local title = parent: getTitle (): gsub ('/ sandbox $', '') local encontrado = falso si coincide con el título (opciones .wrappers, title) then found = true elseif type (options.wrappers) == 'table' then for _, v en pares (options.wrappers) hacer si coincide Título (v, title) luego encontrado = true break end end end - - Probamos falso específicamente aquí para que nil (el predeterminado) actúe como verdadero. si se encuentra o options.frameOnly == false entonces pargs = parent.args end si no se encuentra u options.parentOnly == false entonces fargs = frame.args end end else - options.wrapper no está configurado, así que verifique las otras opciones . si no es options.parentOnly entonces fargs = frame.args end si no options.frameOnly luego local parent = frame: getParent () pargs = parent y parent.args o nil end end si options.parentFirst luego fargs, pargs = pargs, fargs end else luaArgs = frame end - Establece el orden de precedencia de las tablas de argumentos. Si las variables son - nil, no se agregará nada a la tabla, que es la forma en que evitamos choques - entre los argumentos frame / parent y los argumentos Lua. local argTables = {fargs} argTables [#argTables + 1] = pargs argTables [#argTables + 1] = luaArgs - [[- Genera la función tidyVal. Si ha sido especificado por el usuario, lo usamos; si no, elegimos una de cuatro funciones dependiendo de las - opciones elegidas. Esto es para que no tengamos que llamar a la tabla de opciones, cada vez que se llama a la función. -]] local tidyVal = options.valueFunc if tidyVal entonces si type (tidyVal) ~ = 'function' then error ("mal valor asignado a la opción 'valueFunc'" .. '(función esperada, tengo' .. type (tidyVal) .. ')', 2) end elseif options.trim ~ = false, entonces si options.removeBlanks ~ = false entonces tidyVal = tidyValDefault else tidyVal = tidyValTrimOnly end else if options.removeBlanks ~ = false entonces tidyVal = tidyValRemoveBlanks endNo endNo más - - [[- Configura las tablas args, metaArgs y nilArgs. args será al que se acceda desde las funciones, y metaArgs contendrá los argumentos reales. Nil: los argumentos se memorizan en nilArgs, y la metatabla los conecta a todos juntos. -]] local args, metaArgs, nilArgs, metatable = {}, {}, {}, {} setmetatable (args, metatable) función local mergeArgs (tablas) - [[- Acepta varias tablas como entrada y fusiona sus claves y valores - en una tabla. Si un valor ya está presente, no se sobrescribe; - las tablas enumeradas anteriormente tienen prioridad. También estamos memorizando valores nulos, que pueden sobrescribirse si son 's' (blandos). -]] para _, t en pares (tablas) hacer para clave, val en pares (t) hacer si metaArgs [clave] == nil y nilArgs [clave] ~ = 'h' luego local tidiedVal = tidyVal (clave, val) if tidiedVal == nil entonces nilArgs [clave] = 's' else metaArgs [clave] = tidiedVal end end end end end - [[- Definir el comportamiento de metatabla. Los argumentos se memorizan en la tabla metaArgs y solo se obtienen de las tablas de argumentos una vez. Obtener argumentos de las tablas de argumentos es el paso más intensivo en recursos de este módulo, por lo que intentamos evitarlo siempre que sea posible. Por esta razón, los argumentos nulos también se memorizan en la tabla nilArgs. Además, mantenemos un registro, en la metatabla de cuándo se han llamado pares e ipairs, por lo que no ejecutamos pares e ipairs en las tablas de argumentos más de una vez. También hacemos - no ejecutamos ipairs en fargs y pargs si los pares ya se han ejecutado, como todos - los argumentos ya se habrán copiado. -]] metatable .__ index = function (t, key) - [[- Obtiene un argumento cuando la tabla args está indexada. Primero verificamos, para ver si el valor está memorizado, y si no, intentamos obtenerlo de las tablas de argumentos. Cuando verificamos la memorización, debemos verificar - metaArgs antes de nilArgs, ya que ambos pueden ser no nulos al mismo tiempo. - Si el argumento no está presente en metaArgs, también verificamos si - pairs se ha ejecutado todavía. Si los pares ya se han ejecutado, devolvemos nil. - Esto se debe a que todos los argumentos ya habrán sido copiados en - metaArgs por la función mergeArgs, lo que significa que cualquier otro argumento - debe ser nulo. -]] si tipo (clave) == 'cadena' entonces clave = opciones.translate [clave] end local val = metaArgs [clave] si val ~ = nil entonces devuelve val elseif metatable.donePairs o nilArgs [clave] luego regresa nil end for _, argTable in ipairs (argTables) do local argTableVal = tidyVal (key, argTable [key]) if argTableVal ~ = nil then metaArgs [key] = argTableVal return argTableVal end end nilArgs [key] = 'h' return nil end metatable .__ newindex = function (t, key, val) - Esta función se llama cuando un módulo intenta agregar un nuevo valor a la tabla - args, o intenta cambiar un valor existente. if type (key) == 'string' then key = options.translate [key] end if options.readOnly then error ('no se pudo escribir en la clave de la tabla de argumentos "' .. tostring (clave) .. '"; la tabla es de solo lectura', 2) elseif options.noOverwrite y args [key] ~ = nil then error ('no se pudo escribir en la clave de la tabla de argumentos"' .. tostring (clave) .. '"; no se permite sobrescribir argumentos existentes', 2) elseif val == nil entonces - [[- Si el argumento se va a sobrescribir con nil, necesitamos borrar - el valor en metaArgs, de modo que __index, __pairs y __ipairs - no usan un valor previo existente, si está presente; y también necesitamos - memorizar el nil en nilArgs, para que el valor no se busque en las tablas de argumentos si se accede de nuevo. -]] metaArgs [clave] = nil nilArgs [clave] = 'h' else metaArgs [clave] = val end end función local translatenext (invariante) local k, v = next (invariant.t, invariant.k) invariant. k = k si k == nil entonces devuelve nil elseif type (k) ~ = 'cadena' o no options.backtranslate luego devuelve k, v else local backtranslate = options.backtranslate [k] if backtranslate == nil entonces - Saltar Éste. Esta es una llamada de cola, por lo que no causará un desbordamiento de la pila return translatenext (invariant) else return backtranslate, v end end end metatable .__ pairs = function () - Se llama cuando se ejecuta pares en la tabla de argumentos. si no es metatable.donePairs, entonces mergeArgs (argTables) metatable.donePairs = true end return translatenext, {t = metaArgs} end local function inext (t, i) - Esto usa nuestro __index metamétodo local v = t [i + 1] si v ~ = nil luego devuelve i + 1, v end end metatable .__ ipairs = function (t) - Se llama cuando ipairs se ejecuta en la tabla args.