Módulo:Argumentos

Te damos la bienvenida, estás en esta página web tratando de hallar la definición de la palabra Módulo:Argumentos. En esta página web que es Dictious no solo podrás encontrar la totalidad de las acepciones del diccionario para la palabra Módulo:Argumentos, sino que además también te hablaremos de su etimología, sus peculiaridades y aprenderás cómo se dice Módulo:Argumentos en singular y en plural. Cualquier cosa que deberías saber en referencia a la palabra Módulo:Argumentos aquí lo tienes. La definición de la palabra Módulo:Argumentos te servirá de ayuda a que tengas mayor concreción y corrección cuando llegue el momento de conversar o redactar tus textos. Saber la definición deMódulo:Argumentos, de la misma forma que los significados de otras palabras, amplían nuestro vocabulario y nos confieren de mayores y mejores recursos lingüísticos.

La documentación para este módulo puede ser creada en Módulo:Argumentos/doc

local z = {}

function z.obtenerArgumentos(frame)
	if frame.args then 
		return frame.args
	end

	return frame:getParent().args
end

function z.obtenerArgumentosConValor(frame)
	if frame == mw.getCurrentFrame() then
		argumentos = frame:getParent().args
	else
		argumentos = frame.args or frame
	end

	return require('Módulo:Tablas').copiarElementosConValor(argumentos)
end

-- Obtiene los argumentos con valores de la plantilla en minúsculas y con las
-- tildes removidas, en caso de que las tenga de forma que sea más sencillo
-- trabajar con las distintas variantes en los módulos.
-- 
-- Nota: En caso de que haya parámetros duplicados tras la normalización solo
-- se mantendrá el último valor procesado por la función.
--
-- Parámetros de entrada:
--    frame: El marco utilizado por el módulo
--
-- Parámetros de salida:
--    argumentosNormalizados: los argumentos con valor y nombre normalizado
--    argumentosDuplicados: si la plantilla tiene varias veces el mismo 
--        argumento tras la normalización o no
function z.obtenerArgumentosConValorNormalizados(frame)
	local argumentos = z.obtenerArgumentosConValor(frame)
	local argumentosNormalizados = {}
	local nombreNormalizado
	local argumentosDuplicados = false
	
	for nombre, valor in pairs(argumentos) do
		
		nombreNormalizado = nombre
		
		nombreNormalizado = mw.ustring.lower( nombreNormalizado )
		nombreNormalizado = string.gsub(nombreNormalizado, "", "a")
		nombreNormalizado = string.gsub(nombreNormalizado, "", "e")
		nombreNormalizado = string.gsub(nombreNormalizado, "", "i")
		nombreNormalizado = string.gsub(nombreNormalizado, "", "o")
		nombreNormalizado = string.gsub(nombreNormalizado, "", "u")
		
		if argumentosNormalizados then
			argumentosDuplicados = true
		end
		argumentosNormalizados = valor
	end
	
	return argumentosNormalizados, argumentosDuplicados
end

--[[
	@name	obtenerTablaDeArgumentos
	@global	args
	@param	frame
	@return	table
	@descr	Obtiene una tabla de argumentos tomando los parámetros recibidos
			tando desde la plantilla como desde la invocación de un módulo.
			En caso de duplicado tiene preferencia el valor de la invocación.
			Por ejemplo:
				con la plantilla:	{{Plantilla |campo=valor |key=clave }}
				y la invocación:	{{#invoke:Módulo |key=value }}
				se obtiene:			{  = 'valor',  = 'value' }
--]]
function z.obtenerTablaDeArgumentos(frame)
	-- global args
	args = {}
	local function paramMerge(orig, copy)
		local data = {}
		for key, val in pairs(orig) do
			data = val
		end
		for key, val in pairs(copy) do
			data = val
		end
		return data
	end
	if frame then
		-- parentArgs = frame:getParent().args or {}
		if type(frame.getParent) == 'function' then
			local parent = frame:getParent()
			if parent then
				args = paramMerge(args, parent.args)
			end
		end
		-- invokeArgs = frame.args or frame or {}
		if type(frame.args) == 'table' then
			args = paramMerge(args, frame.args)
		elseif type(frame) == 'table' then
			args = paramMerge(args, frame)
		end
	end
	return args
end

--[[
	@name	obtenerValorDeArgumentos
	@global	args
	@param	list
	@return	string or nil
	@descr	Obtiene el primer argumento válido desde una tabla de parámetros.
			Esta tabla de parámetros es una lista que contiene los nombres
			de los argumentos u otras tablas con las funciones para obtenerlos.
	Parámetros:
		con los argumentos:		{  = 'valor',  = 'value' }
		y usando la llamada:	obtenerValorDeArgumentos{'dato', 'campo', 'key'}
		se obtiene el valor:	'valor'
		pues 'dato' no es un argumento y 'campo' es el primero encontrado
	Funciones:
		también se puede llamar con una función de la forma
			obtenerValorDeArgumentos{'dato', { obtenerDato, '1', '2' }}
		de forma que si el argumento 'dato' no existe se llama a la función
			obtenerDato('1', '2')
--]]
function z.obtenerValorDeArgumentos(list)
	-- global args
	local lang = mw.language.getContentLanguage()
	local err, key
	if type(list) == 'number' then
		key = args
	elseif type(list) == 'string' then
		key = args or args
	elseif type(list) == 'table' then
		for num, val in ipairs(list) do
			if type(val) == 'string' then
				key = z.obtenerValorDeArgumentos(val)
			elseif type(val) == 'function' then
				err, key = pcall(val)
				if err ~= true then
					key = nil
				end
			elseif type(val) == 'table' then
				if val and type(val) == 'function' then
					err, key = pcall(val, unpack(val, 2))
					if err ~= true then
						key = nil
					end
				end
			end
			if key ~= nil and key ~= '' then
				return key -- break
			end
		end
	end
	return key
end

return z

Separar Módulo:Argumentos en sílabas

Existe la posibilidad de que al margen todo lo aprendido en lo tocante a la palabra Módulo:Argumentos, ahora también te enseñemos la forma de cómo dividirla en sílabas. Sigue este link si deseas aprender a separar Módulo:Argumentos en sílabas.

Listado de errores ortográficos de Módulo:Argumentos

Abajo damos a conocer un listado con los errores ortográficos más generalizados, de modo que prestes atención y no los cometas.Sin más preámbulos, aquí tienes el listado de errores ortográficos de Módulo:Argumentos