0Pricing
Lua Academy · Lección

Tablas anidadas y datos estructurados

Construya estructuras anidadas y acceda a campos profundos.

Tablas anidadas y datos estructurados es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Conceptos básicos de las tablas anidadas

Las tablas pueden contener otras tablas como valores, lo que permite crear estructuras de profundidad arbitraria. Acceda a los campos anidados encadenando puntos o corchetes. Si faltan tablas intermedias se producen errores; asegúrese siempre de que existan las tablas principales antes de acceder a campos profundos.

local company = {
  name = "CoddyKit",
  address = {
    city = "Istanbul",
    country = "Turkey",
    zip = "34000"
  },
  employees = 25
}

print(company.name)            -- CoddyKit
print(company.address.city)    -- Istanbul
print(company["address"]["zip"]) -- 34000

Acceso profundo seguro

Acceder a un campo de un valor nil provoca el error "attempt to index a nil value". Evítelo usando la evaluación de cortocircuito de and: t and t.a and t.a.b. Algunas bases de código definen un auxiliar get(t, ...) que recorre de forma segura una cadena de claves.

local function get(t, ...)
  local cur = t
  for _, key in ipairs({...}) do
    if type(cur) ~= "table" then return nil end
    cur = cur[key]
  end
  return cur
end

local data = {user = {profile = {age = 30}}}
print(get(data, "user", "profile", "age"))    -- 30
print(get(data, "user", "missing", "field"))  -- nil

Matriz de registros

Un patrón habitual es una matriz de tablas (registros). Cada elemento es una tabla con campos con nombre. Recorra la matriz con ipairs y acceda a los campos por su nombre. Este es el equivalente en Lua de una matriz de objetos o una lista de estructuras.

local users = {
  {id=1, name="Alice", score=95},
  {id=2, name="Bob",   score=87},
  {id=3, name="Carol", score=91},
}

for _, user in ipairs(users) do
  print(user.id, user.name, user.score)
end

Crear tablas anidadas dinámicamente

Construya estructuras anidadas de forma incremental creando las tablas internas cuando sea necesario. Inicialice siempre una tabla antes de insertar elementos en ella. Un error habitual es olvidar crear primero la tabla interna y después intentar indexar nil.

local tree = {}
tree.root = {value = 10}
tree.root.left = {value = 5}
tree.root.right = {value = 15}
tree.root.left.left = {value = 2}

print(tree.root.value)            -- 10
print(tree.root.left.value)       -- 5
print(tree.root.left.left.value)  -- 2

Tabla como configuración similar a JSON

Las tablas de Lua se utilizan a menudo para archivos de configuración, de forma similar a JSON o YAML. El archivo devuelve una tabla y la aplicación la carga con dofile() o require(). Las tablas anidadas representan secciones de configuración anidadas.

-- config.lua (returned table)
local config = {
  server = {
    host = "0.0.0.0",
    port = 8080,
    ssl  = false,
  },
  db = {
    host = "localhost",
    name = "appdb",
    pool_size = 10,
  },
  logging = { level = "info", file = "/var/log/app.log" }
}

print(config.server.port)      -- 8080
print(config.db.pool_size)    -- 10

Grafo como lista de adyacencia

Represente un grafo como una tabla de tablas: cada clave es un nodo y su valor es una lista de vecinos. Esta representación mediante lista de adyacencia ahorra memoria en grafos dispersos y es fácil de utilizar en Lua.

local graph = {
  A = {"B", "C"},
  B = {"A", "D"},
  C = {"A", "D"},
  D = {"B", "C"},
}

-- BFS from A
local visited = {A=true}
local queue = {"A"}
while #queue > 0 do
  local node = table.remove(queue, 1)
  io.write(node .. " ")
  for _, neighbor in ipairs(graph[node]) do
    if not visited[neighbor] then
      visited[neighbor] = true
      queue[#queue+1] = neighbor
    end
  end
end
print()  -- A B C D

Modificar campos anidados

Modifique campos anidados accediendo a la tabla principal y asignando un valor a la clave. Como las tablas se pasan por referencia, cualquier función que reciba una tabla puede modificar su contenido directamente; el código que la llamó verá los cambios.

local player = {name="Hero", stats={hp=100, mp=50, atk=20}}

local function takeDamage(p, dmg)
  p.stats.hp = math.max(0, p.stats.hp - dmg)
end

takeDamage(player, 35)
print(player.stats.hp)   -- 65

player.stats.atk = player.stats.atk + 5
print(player.stats.atk)  -- 25

Serializar tablas anidadas

Convertir una tabla anidada en una cadena resulta útil para depurar o registrar información. Un serializador recursivo sencillo gestiona cualquier profundidad, aunque no gestiona ciclos (referencias circulares).

local function serialize(val, indent)
  indent = indent or 0
  local pad = string.rep("  ", indent)
  if type(val) ~= "table" then
    return tostring(val)
  end
  local parts = {"{"}
  for k, v in pairs(val) do
    parts[#parts+1] = pad.."  "..tostring(k).."="..serialize(v,indent+1)
  end
  parts[#parts+1] = pad.."}"
  return table.concat(parts, "\n")
end
local data = {x=1, nested={y=2, z=3}}
print(serialize(data))

Matrices dispersas

Almacenar ingenuamente una matriz bidimensional desperdicia memoria cuando los datos son grandes y dispersos. Almacene únicamente las entradas distintas de cero en una tabla anidada: matrix[row][col] = value. Esto permite representar matrices enormes de forma eficiente cuando la mayoría de los valores son cero.

local function newMatrix()
  return setmetatable({}, {__index=function(t,k)
    local row = {}
    rawset(t, k, row)
    return row
  end})
end

local m = newMatrix()
m[1][1] = 5
m[3][7] = 12
m[100][200] = 99

print(m[1][1])    -- 5
print(m[3][7])    -- 12
print(m[2][5])    -- nil (sparse: no value)

Comprobar igualdad profunda

Las tablas se comparan por referencia mediante ==, no por valor. Para comparar estructuralmente tablas anidadas, escriba una función de igualdad recursiva que compare cada par clave-valor y se vuelva a llamar para las tablas anidadas.

local function deepEqual(a, b)
  if type(a) ~= type(b) then return false end
  if type(a) ~= "table" then return a == b end
  for k, v in pairs(a) do
    if not deepEqual(v, b[k]) then return false end
  end
  for k in pairs(b) do
    if a[k] == nil then return false end
  end
  return true
end
print(deepEqual({1,{2,3}},{1,{2,3}}))  -- true
print(deepEqual({1,{2,3}},{1,{2,4}}))  -- false

Comprobación rápida

¿Qué ocurre al acceder a t.a.b si t.a es nil?

Repaso: tablas anidadas

Resumen:

  • Las tablas pueden anidarse arbitrariamente: t.a.b.c
  • Proteja el acceso profundo: t and t.a and t.a.b
  • Las tablas son tipos de referencia; las funciones las modifican directamente
  • Matriz de registros: {{name=...},{name=...}}
  • Matriz dispersa: tablas anidadas para ahorrar memoria
  • La igualdad profunda requiere una comparación recursiva

Preguntas frecuentes

¿La lección «Tablas anidadas y datos estructurados» es gratis?

Sí — el texto completo de «Tablas anidadas y datos estructurados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tablas anidadas y datos estructurados»?

Construya estructuras anidadas y acceda a campos profundos. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Tablas anidadas y datos estructurados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Tablas como arrays
  2. Tablas como diccionarios
  3. Iteración de tablas con pairs e ipairs
  4. Tablas anidadas y datos estructurados
← Volver a Lua Academy