Si quedaste totalmente asombrado con la sencillez en la que te puedes manejar entorno a la programación en LUA, con la primera entrega de los tutoriales de programación, ya llega la segunda entrega, de muchas otras más que vendrán y que te dejarán cada vez más asombrado por la sencillez en la cual puedes crear tus propios Homebres gracias a estos geniales tutoriales.

Esta entrega tratará sobre un tipo de variable especial, hablo de las variables tipo table (tablas), o también conocidas como arrays (arreglos).Estas variables son más bien un conjunto de variables o de datos, los cuales pueden ser de distintos tipos, como por ejemplo:

variable = {2,"hola",true}

Se puede observar claramente que los elementos del arreglo son de distinto tipo.

Otra característica de los arreglos es que pueden tener varias dimensiones...

Usando el ejemplo anterior:

variable = {2,"hola",true}

Este arreglo tiene una sola dimensión y tiene 3 elementos, para lograr tener más dimensiones, se insertan arreglos en arreglos, es decir, los elementos de un arreglo pueden ser arreglos también, como por ejemplo:

variable = {{2,"hola",true},
            {"chao",3,false}}

Este arreglo tiene 2 x 3 dimensiones.

Pero los arreglos no siempre tienen dimensiones definidas, estos también pueden tener dimensiones que no sean específicas, es decir, por ejemplo, puede que uno de sus elementos tenga 3 dimensiones y otro 4, otro 5, etc.. , como este:

variable = {{2,"hola",true},
            {"chao",3,false,true},
            {1,2,3,4,5}}

Y te estarás preguntando, ¿Y cómo accedo a los valores dentro de un arreglo?

Fácil, con su índice, por ejemplo, si tengo:

variable = {2,"hola",true}

Si quiero acceder a "hola", tendría que poner el nombre del arreglo seguido del número del índice del elemento al que quiero acceder entre corchetes, en nuestro caso sería:

variable[2]

Eso hace referencia al elemento "hola", ya que busca al elemento 2 de la tabla variable.

Ahora supongamos que tenemos el arreglo de 2 x 3:

variable = {{2,"hola",true},
             {"chao",3,false}}

Para acceder al dato 3 del arreglo dos, se va del más externo al más interno, es decir, primero el número del arreglo y luego el del elemento, en nuestro caso:

variable[2][3]

Hará referencia a false ya que variable[2] sería {"chao",3,false} y luego variable[2][3] sería el tercer elemento de variable[2], que sería, false .

Otra característica de los arreglos o tablas es que tienen varias formas de acceder a sus elementos, como los índices numéricos que ya los hemos visto y los índices por nombres, estos últimos se logran declarando variables dentro de un arreglo, por ejemplo:

jugador = {nombre = "Chimecho",x = 2,y = 10}

Para acceder a estos, se usa el nombre del arreglo, seguido de un punto "." y el nombre de la variable que contiene el dato al que queremos acceder, en nuestro caso:
Se puede acceder al dato "Chimecho" mediante la referencia jugador.nombre, jugador.x para acceder al valor 2 y jugador.y para acceder al valor 10

Resumiendo con algunos ejemplos:

var1 = {1, 2, "Chimecho"}
var2 = {x = 2, y = 10,var3={5}}

La forma de acceder a los valores y sus resultados serían:

var1[1] -> 1
var1[2] -> 2
var1[3] -> "Chimecho"
var2.x -> 2
var2.y -> 10
var2.var3[1] -> 5

Los arreglos no es necesario definirlos al crearlos, se pueden ir agregando campos, tanto numéricos como por nombres. Pueden ir mezclados, esto es, no necesariamente han de ser numéricos o por nombres, pueden contener ambos tipos de claves a la vez, por ejemplo:

mitabla = { } -- creamos mitabla ( vacia, pero del tipo arreglo )
 
mitabla[1] = "Datos aquí."
mitabla[3] = "Más datos, ups, nos hemos saltado el 2!"
 
mitabla.x = 34
mitabla.y = 54
 
mitabla["personaje"] = image.load( ... )

Aquí tenemos una tabla que contiene:

Dos índices numéricos, 1 y 3, con datos y varios índices por nombre, en uno de ellos hay cargada una imagen.

Con esto quiero decir que se pueden cargar cualquier tipo de objetos o datos dentro de una tabla. Asimismo pueden haber tablas dentro de tablas dentro de tablas.... etc...

Bien, para acceder a los datos internos, sería como antes:

mitabla[1] y mitabla[3] tendrán los primeros datos, y

mitabla.x mitabla.y mitabla.personaje (nótese que puedo utilizar mitabla["nombre"] o mitabla.nombre , es lo mismo)

¿Cuanta información contiene nuestra tabla? 5 campos.

Haciendo #mitabla (o table.maxn(mitabla), que es lo mismo ya que el operador de longitud (#) llama a esa función automáticamente si es una tabla) veremos que nuestra tabla mide exactamente... 1

Ehm. ¿Uno? no no, mide más, pero Lua tiene su forma de medir las tablas :D

Lua para medir, realiza un recorrido sólo numérico por la tabla, y en cuanto encuentra un indice vacío, dice que hasta ahi mide la tabla. Así que en este caso, miraría mitabla[1] (OK), mitabla[2] (VACIO), finaliza y el resultado es: 1.

Así que tener cuidado añadiendo indices numéricos manualmente, aunque bueno, existen funciones para ello :P

Extra para perfeccionistas:

En sus códigos, si utilizan el frame by frame, (es decir, redibujan todo), procuren evitar cosas del tipo:

for i = 1, #mitabla do
   --xxx
   -- algo usando #mitabla
   --xxx
end
 
for i = 1, #mitabla do
   --xxx
   --xxx
end

Ya, que si mentalmente pensamos que hacer #mitabla es hacer un for más, y contar posiciones, si en nuestro código no modificamos mitabla en longitud, creeremos que estamos realizando 3 veces un for que nos quitará velocidad.

Es mucho más comodo utilizar en este caso, local longitud = #mitabla; y luego usar longitud, ya que tendrá la información guardada y no tendremos que medir y medir y medir... con la consiguiente pérdida de velocidad.

Tutoriales realizados con la ayuda y asesoramiento de DeViaNTe.