📦Tablas

Las tablas son la estructura de datos más flexible y poderosa en LUA. No solo pueden ser utilizadas como arreglos y diccionarios, sino que también sirven para implementar otros conceptos avanzados como la Programación Orientada a Objetos (POO). Además, LUA proporciona una librería estándar llamada table que facilita la manipulación de tablas.

4.1. Introducción a las Tablas 📊

Las tablas en LUA son estructuras de datos que pueden almacenar cualquier tipo de valor, desde números y cadenas hasta otras tablas y funciones.

4.1.1. Creación de una Tabla

Puedes crear una tabla usando llaves {}.

local miTabla = {}

4.1.2. Tablas como Arreglos

Cuando las tablas se utilizan como arreglos, los índices numéricos se utilizan para acceder a los elementos.

local frutas = {"manzana", "banana", "cereza"}
print(frutas[1])  -- Salida: manzana
print(frutas[2])  -- Salida: banana

4.1.3. Tablas como Diccionarios

Las tablas pueden funcionar como diccionarios, donde se asocian claves (keys) con valores.

local persona = {
    nombre = "Laura",
    edad = 30,
    ciudad = "Madrid"
}

print(persona["nombre"])  -- Salida: Laura
print(persona.edad)       -- Salida: 30

4.1.4. Tablas Anidadas

Las tablas pueden contener otras tablas como elementos, lo que permite crear estructuras más complejas.

local matriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
}

print(matriz[1][2])  -- Salida: 2

4.2. Funciones de la Librería table 🛠️

La librería table proporciona un conjunto de funciones que simplifican la manipulación de tablas. A continuación, se detallan las más importantes.

4.2.1. table.insert

Inserta un valor en una tabla en la posición especificada. Si no se especifica la posición, el valor se añade al final.

local frutas = {"manzana", "banana"}
table.insert(frutas, "cereza")
print(frutas[3])  -- Salida: cereza

4.2.2. table.remove

Elimina un valor de una tabla en la posición especificada. Si no se especifica la posición, se elimina el último valor.

local frutas = {"manzana", "banana", "cereza"}
table.remove(frutas, 2)
print(frutas[2])  -- Salida: cereza

4.2.3. table.sort

Ordena una tabla en orden ascendente. Por defecto, table.sort ordena en base a la comparación de los valores, pero también puede aceptar una función de comparación personalizada.

local numeros = {5, 3, 8, 1}
table.sort(numeros)
for i, v in ipairs(numeros) do
    print(v)  -- Salida: 1 3 5 8
end

4.2.4. table.concat

Concatena los elementos de una tabla en una sola cadena, separados por un delimitador opcional.

local frutas = {"manzana", "banana", "cereza"}
local cadena = table.concat(frutas, ", ")
print(cadena)  -- Salida: manzana, banana, cereza

4.2.5. table.unpack

Devuelve todos los elementos de una tabla como valores separados. Es útil para pasar elementos de una tabla como argumentos a una función.

local frutas = {"manzana", "banana", "cereza"}
local primera, segunda, tercera = table.unpack(frutas)
print(primera, segunda, tercera)  -- Salida: manzana banana cereza

4.2.6. table.pack

table.pack empaqueta los argumentos dados en una tabla, similar a {...} pero con un campo adicional n que contiene el número total de elementos.

local t = table.pack(1, 2, 3, nil, 5)
print(t.n)  -- Salida: 5
for i = 1, t.n do
    print(t[i])
end
-- Salida:
-- 1
-- 2
-- 3
-- nil
-- 5

4.2.7. table.find (No es parte de la librería estándar)

Si bien table.find no es una función estándar de LUA, se puede implementar para buscar un valor en una tabla y devolver el índice correspondiente.

Ejemplo de implementación:

function table.find(tabla, valor)
    for i, v in ipairs(tabla) do
        if v == valor then
            return i
        end
    end
    return nil
end

local frutas = {"manzana", "banana", "cereza"}
local indice = table.find(frutas, "banana")
print(indice)  -- Salida: 2

4.2.8. table.maxn (Desaprobado)

En versiones anteriores de LUA, table.maxn devolvía el mayor índice numérico de una tabla. Sin embargo, esta función está desaprobada a partir de LUA 5.2. Se recomienda usar otras funciones como # para obtener la longitud de la tabla.

4.3. Metatables y Metaprogramación 🧠

Las metatables permiten modificar el comportamiento predeterminado de las tablas, como definir operaciones personalizadas.

4.3.1. Introducción a las Metatables

Una metatable es una tabla que puede cambiar el comportamiento de otra tabla. Se puede asignar una metatable a una tabla utilizando la función setmetatable.

local miTabla = {}
local miMetatable = {}

setmetatable(miTabla, miMetatable)

4.3.2. Métodos Metamágicos (__index, __newindex, etc.)

Los métodos metamágicos en metatables permiten personalizar las operaciones de las tablas. Algunos de los más comunes son __index y __newindex.

• __index: Se usa cuando se intenta acceder a una clave que no existe en la tabla.

local miTabla = {a = 1, b = 2}

local metatable = {
    __index = function(tabla, clave)
        if clave == "c" entonces
            return 3
        else
            return nil
        end
    end
}

setmetatable(miTabla, metatable)
print(miTabla.c)  -- Salida: 3

• __newindex: Se usa cuando se intenta asignar un valor a una clave que no existe en la tabla.

local miTabla = {}

local metatable = {
    __newindex = function(tabla, clave, valor)
        rawset(tabla, clave, valor * 2)
    end
}

setmetatable(miTabla, metatable)
miTabla.a = 10
print(miTabla.a)  -- Salida: 20

4.4. Iteradores y la Función pairs/ipairs 🔄

LUA proporciona funciones integradas para iterar sobre tablas.

4.4.1. pairs

pairs itera sobre todos los pares clave-valor en una tabla. Es útil para tablas que funcionan como diccionarios.

local persona = {
    nombre = "Laura",
    edad = 30,
    ciudad = "Madrid"
}

for clave, valor in pairs(persona) do
    print(clave, valor)
end
-- Salida:
-- nombre    Laura
-- edad      30
-- ciudad    Madrid

4.4.2. ipairs

ipairs itera sobre los índices numéricos de una tabla, por lo que es ideal para tablas que funcionan como arreglos.

local frutas = {"manzana", "banana", "cereza"}

for i, fruta in ipairs(frutas) do
    print(i, fruta)
end
-- Salida:
-- 1  manzana
-- 2  banana
-- 3  cereza

4.4.3. Implementación de Iteradores Personalizados

LUA permite crear iteradores personalizados utilizando funciones. Un ejemplo simple sería un iterador que recorre una tabla en orden inverso.

function reverse_ipairs(t)
    local function iter(t, i)
        i = i - 1
        if i > 0 then
            return i, t[i]
        end
    end
    return iter, t, #t + 1
end

local frutas = {"manzana", "banana", "cereza"}

for i, fruta in reverse_ipairs(frutas) do
    print(i, fruta)
end
-- Salida:
-- 3  cereza
-- 2  banana
-- 1  manzana

Anexo: Diccionarios vs Arreglos en LUA

Las tablas en LUA son extremadamente flexibles y pueden funcionar tanto como arreglos (listas indexadas numéricamente) como diccionarios (colecciones de pares clave-valor). Este anexo explica las diferencias entre estos dos usos y cómo elegir el enfoque adecuado según el contexto.

1. Arreglos en LUA 📚

Un arreglo es una tabla en la que los elementos están indexados por números consecutivos, comenzando generalmente desde 1. Este tipo de tabla se usa cuando necesitas almacenar una secuencia ordenada de elementos.

1.1. Características de un Arreglo:

• Índices numéricos: Los elementos están indexados por números enteros positivos.

• Orden: Los elementos están ordenados y se puede acceder a ellos por su posición.

• Uso típico: Listas de elementos, vectores, matrices.

1.2. Ejemplo de Arreglo:

local frutas = {"manzana", "banana", "cereza"}
print(frutas[1])  -- Salida: manzana
print(frutas[3])  -- Salida: cereza

-- Iteración sobre un arreglo
for i = 1, #frutas do
    print(frutas[i])
end
-- Salida:
-- manzana
-- banana
-- cereza

1.3. Operaciones Comunes:

• Acceso: frutas[1] (accede al primer elemento).

• Inserción: table.insert(frutas, "naranja") (agrega un elemento al final).

• Eliminación: table.remove(frutas, 2) (elimina el segundo elemento).

• Longitud: #frutas (devuelve el número de elementos en el arreglo).

2. Diccionarios en LUA 🗃️

Un diccionario es una tabla donde los elementos están indexados por claves arbitrarias, en lugar de por números. Este tipo de tabla se usa cuando necesitas asociar valores con nombres o identificadores específicos.

2.1. Características de un Diccionario:

• Claves arbitrarias: Las claves pueden ser de cualquier tipo, generalmente cadenas.

• Sin orden: No hay un orden inherente en los pares clave-valor.

• Uso típico: Asociar datos con nombres, como en una lista de propiedades o un conjunto de configuraciones.

2.2. Ejemplo de Diccionario:

local persona = {
    nombre = "Laura",
    edad = 30,
    ciudad = "Madrid"
}

print(persona["nombre"])  -- Salida: Laura
print(persona.edad)       -- Salida: 30

-- Iteración sobre un diccionario
for clave, valor in pairs(persona) do
    print(clave .. ": " .. valor)
end
-- Salida:
-- nombre: Laura
-- edad: 30
-- ciudad: Madrid

2.3. Operaciones Comunes:

• Acceso: persona["nombre"] o persona.nombre (accede al valor asociado a la clave nombre).

• Inserción/Actualización: persona["pais"] = "España" (agrega o actualiza un par clave-valor).

• Eliminación: persona["edad"] = nil (elimina el par clave-valor asociado a edad).

• Iteración: for k, v in pairs(persona) (itera sobre todos los pares clave-valor).

3. Comparación: Diccionario vs Arreglo

3.1. Índices vs Claves:

• Arreglos: Utilizan índices numéricos consecutivos que permiten acceder a los elementos en un orden definido.

• Diccionarios: Utilizan claves arbitrarias, lo que permite un acceso más flexible a los datos, pero sin un orden inherente.

3.2. Uso de pairs vs ipairs:

• Arreglos: Se suelen recorrer con ipairs, que garantiza un recorrido ordenado por los índices numéricos.

• Diccionarios: Se recorren con pairs, que no garantiza el orden de los elementos.

3.3. Casos de Uso:

• Arreglos: Ideales para listas ordenadas de elementos, como una lista de tareas o una serie de datos secuenciales.

• Diccionarios: Útiles para almacenar configuraciones, propiedades de un objeto, o cualquier situación donde necesites acceder a valores por un identificador descriptivo.

3.4. Ejemplo Comparativo:

Arreglo:

local colores = {"rojo", "verde", "azul"}
print(colores[2])  -- Salida: verde

Diccionario:

local datos = {nombre = "Laura", edad = 30}
print(datos["nombre"])  -- Salida: Laura

4. Resumen:

• Usa un arreglo cuando necesitas una lista ordenada de elementos a los que accederás por posición.

• Usa un diccionario cuando necesitas asociar valores a claves específicas y no te importa el orden de los elementos.