Uno de los lenguajes utilizados para desarrollar videojuegos es LUA (usado en Corona SDK) y una de las estructuras mas poderosas de este lenguaje son las tablas.
En otros lenguajes de programación existen estructuras de datos como las Clases pero LUA solo usa tablas como la única estructura de datos disponible, sin embargo con ellas es posible crear estructuras como Arreglos y Diccionarios. Veamos como se crea una tabla y como podemos manipularla.
Declaración e inicialización
LUA utiliza la expresion {} como constructor para crear una tabla en blanco y, como sucede en otros lenguajes, dentro de este constructor pueden agregarse valores como Strings o números separados por comas (,) para que inicie con valores por defecto o inicializar la tabla como un arreglo asociativo (llave – valor).
--inicialización de una tabla en blanco
local miTabla = {}
--Inicialización de una tabla con Strings
local miTabla = {"manzana", "naranja", "plátano"}
--Inicialización con múltiples tipos de datos
local miTabla = {1, 3, 5, "manzana", "banana"}
--Inicialización como tabla de valores asociativos
local miTabla = {
nombre = "Jhon",
apellido = "Doe",
edad = 25
}
extraer Información de una tabla
Para extraer un valor contenido en una tabla de LUA se puede hacer colocando [] luego del nombre de la tabla y dentro de estos colocar el indice (posición del elemento dentro de la tabla) .
local miTabla = {"manzana", "naranja", "plátano", "fresa", "kiwi"}
print ( miTabla[1] ) --muestra manzana
print ( miTabla[3] ) --muestra plátano
En caso de que la tabla haya sido creada como tabla de valores asociativos se usa el nombre de la llave que almacena el valor.
local miTablaAsociativa = {
nombre = "Jhon",
apellido = "Doe",
edad = 25
}
print ( miTablaAsociativa["apellido"] ) --muestra Doe (acceso como indice de un arreglo)
print ( miTablaAsociativa.edad ) --muestra 25 (acceso como una propiedad)
Iteración de una tabla
Para recorrer y explorar todos los valores de una tabla se puede hacer por medio de una estructura de ciclo FOR como se observa en los siguientes ejemplos:
local miTabla = {"manzana", "naranja", "sandia"}
local indiceMaximo = #miTabla
for indice=1,indiceMaximo do
print( miTabla[indice] )
end
--[[
La salida en consola será:
>manzana
>naranja
>sandia
]]
Para obtener los elementos de una tabla con valores asociativos
local miTablaAsociativa = {
nombre = "Jhon",
apellido = "Doe",
edad = 25
}
for llave, valor in pairs(miTablaAsociativa) do
print( llave .." - ".. valor )
end
--[[
La salida en consola será:
>nombre - Jhon
>apellido - Doe
>edad - 25
]]
Insertar elementos
Si requieres insertar elementos lo puedes hacer usando uno de los siguientes elementos:
table.insert( t, value ) table.insert( t, pos, value )
En los métodos la letra t es el nombre de la tabla, pos indica la posición o indice y value el valor del elemento en la tabla.
--Ejemplo 1
local miTabla = {"me", "gusta"}
table.insert (miTabla, "la fruta" )
-- La tabla resultante se ve así:
-- {"me", "gusta", "la fruta"}
--Ejemplo 2
local otraTabla = {"me", "gusta", "videojuegos"}
table.insert ( otraTabla, 3, "programar")
-- La tabla resultante se ve así:
-- {"me", "gusta", "programar", "videojuegos"}
Sin embargo el método insert funcionará de forma diferente si estamos trabajando con una tabla asociativa.
Como la tabla asociativa esta basada en elementos del tipo llave – valor, si usamos el método insert el nuevo valor será asignado a una llave con índice numérico. Para insertar una nueva llave – valor tenemos que asignar un nuevo nombre de propiedad siguiendo la regla: nombre_tabla.nombre_propiedad = el_valor como sucede en el siguiente ejemplo:
--Ejemplo de insert en tablas asociativas
local unaTablaAsociativa = {
nombre = "Jhon",
apellido = "Doe"
}
--Insertando un nuevo valor usando el método insert
table.insert ( unaTablaAsociativa, "Programador")
--[[ La tabla resultante se ve algo asi
local unaTablaAsociativa = {
1 = "Programador", -- Como no se puede definir la llave se asigna un índice numérico
nombre = "Jhon",
apellido = "Doe"
}
--]]
--Para insertar una llave y asociar un valor es necesario agregar
--una nueva llave por medio de un .
unaTablaAsociativa.donde_trabaja = "Dreamers Corp"
--[[ La tabla resultante se ve algo asi
local unaTablaAsociativa = {
1 = "Programador"
nombre = "Jhon",
apellido = "Doe",
donde_trabaja = "Dreamers Corp"
}
--]]
Como pudimos observar en el ejemplo anterior las tablas asociativas insertan una llave valor de forma diferente. Esto es importante que lo tengas en cuenta pues aplica para todos los objetos que están basados en una tabla de datos (como por ejemplo los que puedes crear con la librería display en el framework de Corona).
Eliminar elementos
Para eliminar un elemento en una tabla se puede realizar usando uno de estos métodos:
table.remove( t ) table.remove( t, pos )
Así como en los métodos insert la letra t es el nombre de la tabla, y pos indica la posición o índice del elemento
local miTable = {"me", "gusta", "programar", "videojuegos", "con", "LUA"}
table.remove( miTabla ) -- Elimina el último elemento en la tabla
-- La tabla resultante sería:
-- {"me", "gusta", "programar", "videojuegos", "con"}
table.remove ( miTabla, 4)
-- La tabla resultante sería:
-- {"me", "gusta", "programar", "con"}
manipulación de tablas
LUA tiene un conjunto de métodos que nos permiten trabajar con tablas de una forma mas eficiente, veamos cuáles son y como podemos usarlos.
[su_table]
unpack( list [ , i [ , j ] ] )
Devuelve los elementos contenidos en una tabla. |
[/su_table]
Por ejemplo:
local miTabla = {"a", "b", "c", "d", "e", "f"}
print( unpack( miTabla ) ) -- Muestra: a b c d e f
print( unpack( miTabla, 4 ) ) -- Muestra: d e f
print( unpack( miTabla, 2, 5) ) -- Muestra: b c d e
[su_table]
table.concat (table [ , sep [ , i [ , j ] ] ] )
Devuelve un String con los elementos concatenados de la tabla |
[/su_table]
Por ejemplo:
local miTabla = {"a", "b", "c", "d", "e", "f"}
print( table.concat( miTabla ) ) -- Muestra: abcdef
print( table.concat( miTabla, "-" ) ) -- Muestra: a-b-c-d-e-f
print( table.concat( miTabla, " / " , 3 ) ) -- Muestra: c / d / e / f
print( table.concat( miTabla, " / " , 2 , 4 ) ) -- Muestra: b / c / d
[su_table]
table.sort ( table )
Método que permite ordenar los valores contenidos en una tabla. |
[/su_table]
Por ejemplo:
local miTabla = {3, 6, 2, 7, 5 ,9}
table.sort( miTabla)
-- El resultado final de la tabla es:
-- {2, 3, 5, 6, 7, 9}
Para poder sacar provecho de una tabla es muy importante conocer como manipularlas. ¿Conoces alguna función adicional para manipular tablas? Si tienes alguna duda o inquietud puedes dejarnos un comentario y con gusto complementaremos la información de esta publicación.
Espero hayas disfrutado y aprendido muchas cosas de esta entrada y por favor siéntete libre de compartir esta información en tus redes sociales para que otras personas interesadas también puedan conocer algo nuevo y que les pueda ayudar en sus proyectos futuros. ¡Hasta la próxima!