PDF de programación - Programación Lua por Venkman

Programacion Lua por Venkman

Introducción a Lua

Escrito por Venkman bajo una licencia de Creative Commons
Lua es un lenguaje de scripting diseñado con el principal objetivo de ser ligero y extensible. El
pequeño tamaño de su runtime y su API C sencilla han hecho que sea elegido en muchas ocasiones
para ser embebido en aplicaciones como nmap o Monotone, o en multitud de juegos (WOW,
FarCry...). De hecho, viene utilizándose en videojuegos desde hace unos diez años.
Lua apareció por primera vez en 1998 y tiene su origen en la Universidad Pontifica Católica de Rio
de Janeiro [PUC-Rio].

El lenguaje
Lua es un lenguaje sencillo. Una de sus principales influencias declaradas es Lisp y su idea de una
única estructura, la lista. En el caso de Lua, esta estructura clave fundamental de su arquitectura es
la tabla. Como lenguaje más parecido podría nombrarse Javascript. Ambos son lenguajes de script,
con soporte para OO basada en prototipos.
Lua es rápido para su naturaleza interpretada; suele quedar en buen lugar en las comparativas.
La sintaxis recuerda a una mezcla de Pascal con otros lenguajes. Un clásico:
-- Una función:
function diHola(persona)

print("Hola " .. persona .. "!")

-- Un bucle:
for i=1,3 do
end

end
print("¿Cómo te llamas?")
nombre = io.read()
-- Llamada a una función:
diHola(nombre)

Lua soporta un estilo procedural imperativo, pero también un estilo funcional. De hecho, en Lua las
funciones son entidades de primera categoría. La función del ejemplo anterior, en realidad se
interpreta como:
diHola = function(persona)

print("Hola " .. persona .. "!")

end

Si tenéis cierta experiencia con Javascript quizá esa forma de escribirlo os sea familiar.
Lua, como decía antes, también soporta orientación a objetos, y lo hace basándose en la estructura
de la tabla. Una tabla como t:
t = {}

puede contener funciones, como:
function t.diHola(persona)
end
t.diHola("Peter")

print("Hola " .. persona .. "!")

O, si utilizamos : en lugar de . Lua nos pasará como primer parámetro self, una referencia a la tabla
(u objeto):
t = {}
t.nombre = "Peter"
function t:diHola()
end
t:diHola()
-- Que es lo mismo que t.diHola(t) o que t['diHola'](t)

print("Hola " .. self.nombre .. "!")

Con esto tenemos todo lo necesario para encapsular objetos. Para otros aspectos de la OO, Lua se se
basa en la idea de metatabla, una forma de asociar a una tabla T otra T' en la que se irán a buscar los
métodos que no se encuentren en T. Con esto tenemos un mecanismo de herencia. Entrar en detalle
del manejo de las metatablas, OO, metaprogramación u otros aspectos más avanzados quedan
(quizá) para posibles próximos artículos.

Referencias y Herramientas
La referencia fundamental para aprender Lua es, sin duda, el libro Programming in Lua, del cual se
puede encontrar online la primera edición. Es un buen libro, bien escrito y con explicaciones
detalladas pero asequibles a cualquiera. Como complemento, el Manual de Referencia que también
se puede adquirir impreso o consultar online.
La otra referencia habitual es el Wiki de Usuarios de Lua donde podemos encontrar tutoriales y
código, su lista de correo lua-l o el canal de IRC en Freenode.
Existen, además, unos cuantos libros y tutoriales más específicamente orientados a desarrollar
modificaciones de determinados juegos, o a la programación de juegos en general.
El soporte por parte de los editores e IDEs es suficientemente amplio. Personalmente recomiendo
SciTE un editor muy sencillo con la cualidad de que utiliza Lua para programar macros. Existen
también una buena cantidad de librerías y enlaces que se encuentran listadas en el Wiki.
LuaForge es un buen lugar para encontrar proyectos de y para este lenguaje. El Kepler Project es
otra interesante referencia que desarrolla y mantiene una variada colección de módulos principal
pero no exclusivamente orientados al desarrollo web.
Por último, para comenzar con Lua en Windows se puede encontrar un cómodo instalador que
incluye binarios de Lua, un buen número de librerías fundamentales y el editor SciTE, además de
unos cuántos ejemplos y documentación.
Fuente: http://es.debugmodeon.com/articulo/introduccion-a-lua

[Lua] Detalles de sintaxis

Palabras reservadas
Lua cuenta con una lista relativamente pequeña de palabras reservadas. El lenguaje tan sólo define
21 de ellas.
And break do else elseif
end false for function if
in local nil not or
repeat return then true until
while

Los comentarios de una única línea comienzan por dos guiones (--) y los bloques de comentario
están delimitados por --[[ y ]]

Variables y Tipos
Lua es un lenguaje dinámico. No es necesario declarar el tipo de las variables, puesto que estas no
tienen tipo. Los valores que pueden almacenar pueden ser de uno de los 8 tipos básicos que existen
en Lua: nil, boolean, number, string, userdata, function, thread y table.
Se puede acceder a una variable antes de haberle asignado ningún valor. No se considera un error y
su valor en ese caso será nil. nil es el único valor del tipo nil y su función es esta, ser distinto a
cualquier otro valor.
Lua es de esos lenguajes que consideran como false los valores false y nil, y cualquier otra cosa
como true. Detalle: 0 y "" se evalúan como true en una condición. Lo único posiblemente diferente
de otros lenguajes en cuanto a las cadenas de texto es la posibilidad de delimitarlas con [[ y ]]
permitiendo así que contengan saltos de línea y otros caracteres literales.
Como en Javascript, por ejemplo, Lua realiza conversiones automáticas entre cadenas y números.
Pero a diferencia de Javascript, si comparamos 10 y "10" no nos devuelve true.
La tabla es el tipo único de Lua para manejar todas las colecciones y estructuras de datos. table
implementa un array asociativo y todo en Lua se organiza en torno a las tablas. De hecho, cuando
llamamos a io.read(), una función de la librería o módulo io, lo que realmente estamos haciendo es
acceder al elemento read de la tabla io. Las tablas son objetos dinámicos que se construyen siempre
a partir de una expresión de tabla, como {} para una tabla vacía.
Como decíamos en el primer artículo de la serie, las funciones son entidades de primera categoría
en Lua. Su tipo es function.
El tipo userdata sirve para tipos de datos que vienen de C (i.e. del sistema externo donde esté
insertado Lua), y thread es el tipo que implementan las corutinas, que Lua soporta para ofrecer
programación multihilo.
Construcciones básicas y bloques
Lua soporta -como se puede ver más arriba, en la lista de palabras reservadas- las construcciones
típicas de bucles, asignaciones, condicionales, etc. La sintaxis puede recordar ligeramente a algún
lenguaje tipo Pascal, sobre todo por los bloques delimitados por la palabra end.
Los bloques no sólo delimitan los trozos de código sino que también establecen el alcance de las
variables declaradas como locales.
while i < 10 do

local x = i +1
-- ...

end

La variable x, declarada como local, sólo tiene alcance dentro del bloque while-do-end. Una
variable local puede utilizar el mismo nombre que una (más) global y entonces enmascarará su
referencia. Dentro del bloque x siempre hará referencia a la variable local.
Un detalle interesante de Lua es que soporta asignación múltiple directa, sin necesidad de utilizar
listas u otros mecanismos. También las funciones pueden, y muy habitualmente así lo hacen las de
las librerías estándar, devolver varios valores. Más aún, la asignación múltiple se considera una
operación atómica, de modo que es perfectamente posible intercambiar dos valores en una única
instrucción sin efectos secundarios:
a = 1
b = 2
a,b = b,a
print("a: " .. a .. ", b: " .. b)
-- imprimirá: a: 2, b: 1

El intérprete automáticamente descarta los valores sobrantes o rellena con nils hasta completar la
cantidad necesaria de valores sin que suponga error.
a,b,c = 1,2 -- c quedará sin asignar
a,b = 1,2,3,4 -- 3 y 4 se descartan

Funciones
Como decía, las funciones en Lua pueden devolver varios valores. Es simple cuestión de separarlos
por comas en la instrucción return. e.g.:
function numeros()
end

return 1,2,3,4

Similarmente, una función puede aceptar un número variable de argumentos declarando su firma
con ...:
function imprimir(...)
end

print(...)

Para quienes hayan visto algo de Perl, ... es similar a lo que allí sería @_
Las funciones, como hemos visto al hablar de los tipos, son valores de primera categoría. Esto
quiere decir que igual que con otros valores, podemos asignarlos, pasarlas como parámetro,
declararlas como local, etc.
Como otros detalles interesantes, Lua soporta closures y hace correctamente eliminación de
llamadas finales (soporta recursividad de cola... proper tail recursion). También soporta, apoyado
por las closures, un modo sencillo de definir iteradores, que se basa en devolver una función.
Fuente: http://es.debugmodeon.com/articulo/lua-detalles-de-sintaxis

[Lua] Tablas y metatablas (parte I)

En Lua las tablas son la base de cualquier estructura de datos. Y no se quedan sólo ahí, sino que
proporcionan todos los mecanismos para la organización y arquitectura del código.

Tablas
Como vimos en la introducción de esta serie sobre Lua, table es uno de los 7 tipos existentes en
Lua. Su creación se hace siempre a través de una expresión constructora de tabla. En su versión

mínima, la tabla vacía, es así:
tabla = {}

table implementa lo que normalmente conocemos como array asociativo con algunas
peculiaridades. Si no especificamos claves, como en un array sencillo como:
tabla = {1,2,3,4,5,6}

Se aisgnan claves numéricas automáticamente (es decir, como un array tradicional). El detalle es
que Lua es uno de esos lenguajes en que los índices de los arrays empiezan en 1 ;) Podemos hacer
que empiecen por 0, pero la costumbre y convención es que empiecen por 1.
Con un array podemos hacer todas las