2º Entrega: Arrays

Bien, como he tenido este día libre, les daré la segunda entrega este mismo día…
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 = "Checho",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 nuetro caso:
Se puede acceder al dato «Checho» 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, "Checho"}
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] -> "Checho"
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 contenter ambos tipos de claves a la vez, por ejemplo:

mitabla = { } -- creamos mitabla ( vacía, 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. Así mismo 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 😀

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 😛

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, tendremos 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.

Saludos a todos los que me siguen! 😀

Volver al índice

CSBAW & CSBUG Video! »« 1º Entrega: Variables