Anuncios

Bienvenidos sean a este post, en el post anterior vimos como llamar a un modulo pero hoy veremos como crear uno y su forma mas simple es creando una tabla, pon todas las funciones que quieras para exportar en su interior y devolver esta tabla, veamos el siguiente codigo:

complejo = {}

function complejo.nuevo(r, i) return {r=r, i=i} end

complejo.i = complejo.nuevo(0,1)

function complejo.agregar(c1, c2)
	return complejo.nuevo(c1.r + c2.r, c1.i + c2.i)
end

function complejo.sub(c1, c2)
	return complejo.nuevo(c1.r - c2.r, c1.i - c2.i)
end

function complejo.mul(c1, c2)
	return complejo.nuevo(c1.r*c2.r - c1.i*c2.i,
				c1.r*c2.r + c1.i*c2.i)
end

local function inv(c)
	local n = c.r^2 + c.i^2
	return complejo.nuevo(c.r/n, -c.i/n)
end

function complejo.div(c1, c2)
	return complejo.mul(c1, inv(c2))
end

return complejo
Anuncios

Este codigo ilustra el enfoque observen como definimos inv como un nombre privado simplemente declarandolo como local en el chunk, el uso de tablas por modulos no provee exactamente la misma funcionalidad como la provista por modulos reales.

Primero debemos poner explicitamente el nombre del modulo en cada definicion de funcion, segundo una funcion que llama a otra funcion dentro del mismo modulo debe calificar el nombre de la funcion llamada, podemos mejorar estos problemas usando un nombre local fijo para el modulo y luego asignar este nombre local al final del modulo, siguiendo estas recomendaciones escribiremos nuestro modulo previo como sigue:

local M = {}
complejo = M

M.i = {r=0, i=0}
function M.nuevo(r, i) return {r=r, i=i} end

function M.agregar(c1, c2)
	return M.nuevo(c1.r + c2.r, c1.i + c2.i)
end

function M.sub(c1, c2)
	return M.nuevo(c1.r - c2.r, c1.i - c2.i)
end

.... el resto del modulo ....

Cuando una funcion llama a otra funcion dentro del mismo modulo o cuando se llama a si misma recursivamente, aun necesita prefijar el nombre, al menos la conexion entre las dos funciones no depende del nombre del modulo nunca mas, mas aun hay un solo lugar en todo el modulo donde escribimos el nombre del modulo, en realidad podriamos evitar de hacerlo porque require lo pasa como un argumento para el modulo:

local nombreModulo = ...
local M = {}

_G[nombreModulo] = M

... como antes ...
Anuncios

Con este cambio lo unico que debemos hacer para renombrar un modulo es renombrar el archivo que lo define, otra pequeña mejora se relaciona a la declaracion de devolucion de cierre porque seria mas armonioso que pudieramos concentrar toda las tareas de configuracion relacionada al modulo al comienzo del mismo, una manera de eliminar la necesidad de la declaracion de devolucion es asignar la tabla del modulo directamente dentro de package.loaded:

local nombreModulo = ...
local M = {}

_G[nombreModulo] = M
package.loaded =[nombreModulo] = M

... como antes ...

Con esta asignacion no tenemos necesidad de devolver a M al final del modulo.

Nota: Recuerden que si un modulo no devuelve un valor, require devuelve el valor actual de package.loaded
Anuncios

En resumen, hoy hemos visto como escribir un modulo desde una forma muy basica, desde una estructura super basica, hasta conceptos que debemos tener en cuenta y como finalmente optimizarlo usando una regla propia del lenguaje, espero les haya sido util sigueme en Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.

Tengo un Patreon donde podes acceder de manera exclusiva a material para este blog antes de ser publicado, sigue los pasos del link para saber como.

Tambien podes donar

Es para mantenimiento del sitio, gracias!

$1.00