Lua Academy · Lección

Tablas como diccionarios

Utilice claves de tipo string y mixtas para almacenar pares clave-valor.

Tablas como diccionarios es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 2 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.

Claves de tipo cadena

Las tablas con claves de tipo cadena actúan como diccionarios (tablas hash). Acceda a los campos mediante la notación de punto t.key (para identificadores válidos) o la notación de corchetes t["key"] (para cualquier cadena). Ambas formas son equivalentes; la notación de corchetes permite usar claves dinámicas.

local user = {}
user.name = "Alice"
user["age"] = 30
user.role = "admin"

print(user.name)        -- Alice
print(user["age"])      -- 30

local field = "role"
print(user[field])      -- admin (dynamic key)

Literales de tabla

Los diccionarios pueden inicializarse con un literal de tabla mediante la sintaxis key = value. Esta es la forma más habitual de crear registros en Lua. Puede combinar entradas de estilo matriz y de estilo diccionario en un mismo literal.

local config = {
  host = "localhost",
  port = 3306,
  database = "myapp",
  debug = false,
  tags = {"web", "api"},  -- nested array
}

print(config.host)        -- localhost
print(config.port)        -- 3306
print(config.tags[1])     -- web

Contar con diccionarios

Un caso de uso clásico de los diccionarios es contar frecuencias. Recorra una lista, use cada elemento como clave e incremente el contador. Compruebe si el valor es nil antes de incrementarlo; use count[word] or 0 como valor inicial.

local words = {"lua","is","fast","lua","is","lua"}
local freq = {}

for _, w in ipairs(words) do
  freq[w] = (freq[w] or 0) + 1
end

for word, count in pairs(freq) do
  print(word, count)
end
-- lua 3, is 2, fast 1

Agrupar con diccionarios

Para agrupar datos por una propiedad, recorra la lista y use la clave de agrupación para añadir elementos a una lista dentro de un diccionario. Este es el equivalente en Lua de GROUP BY de SQL o del patrón defaultdict de Python.

local people = {
  {name="Alice", dept="eng"},
  {name="Bob",   dept="hr"},
  {name="Carol", dept="eng"},
  {name="Dave",  dept="hr"},
}
local groups = {}

for _, p in ipairs(people) do
  local d = p.dept
  groups[d] = groups[d] or {}
  groups[d][#groups[d]+1] = p.name
end

print(table.concat(groups.eng, ", "))  -- Alice, Carol

Comprobar si existe una clave

Compruebe si existe una clave comparando su valor con nil. Tenga cuidado: si el valor almacenado en una clave es nil, la clave se considera ausente. Para indicar presencia, almacene true como valor en lugar de nil.

local cache = {result=42, mode="fast"}

if cache.result ~= nil then
  print("cached:", cache.result)  -- 42
end

-- Key not present:
if cache.timeout == nil then
  print("no timeout set")
end

-- Membership set pattern
local allowed = {admin=true, editor=true}
if allowed["admin"] then
  print("access granted")
end

Eliminar claves

Asigne nil a una clave de tabla para eliminarla. El par clave-valor desaparece y el recolector de basura puede recuperar la memoria del valor. No puede eliminar una variable local de esta forma; solo entradas de una tabla.

local session = {token="abc123", user="Alice", expires=3600}
print(session.token)   -- abc123

session.token = nil
print(session.token)   -- nil (removed)

-- Count remaining keys
local count = 0
for _ in pairs(session) do count = count + 1 end
print(count)   -- 2

Combinar diccionarios

Combine dos tablas recorriendo una y copiando sus entradas en la otra. Si ambas tienen la misma clave, prevalece el valor de la segunda tabla. Este es el equivalente en Lua de Object.assign de JavaScript.

local defaults = {color="blue", size=12, bold=false}
local overrides = {color="red", italic=true}

local function merge(base, over)
  local result = {}
  for k, v in pairs(base) do result[k] = v end
  for k, v in pairs(over) do result[k] = v end
  return result
end

local opts = merge(defaults, overrides)
print(opts.color, opts.size, opts.italic)  -- red 12 true

Cualquier tipo de clave

Las claves de una tabla pueden ser cualquier valor que no sea nil ni NaN: cadenas, números, booleanos, funciones e incluso otras tablas. Las claves enteras y las claves de tipo cadena se almacenan internamente de forma distinta, pero se accede a ellas de manera uniforme mediante la notación de corchetes.

local t = {}
local function myKey() end

t["string"] = 1
t[42] = 2
t[true] = 3
t[myKey] = 4

print(t["string"])  -- 1
print(t[42])        -- 2
print(t[true])      -- 3
print(t[myKey])     -- 4

Recorrido ordenado

pairs() de Lua no garantiza el orden del recorrido. Para recorrer una tabla en un orden definido, recopile las claves en una matriz, ordénela y después recórrala.

local scores = {Alice=95, Bob=87, Carol=91, Dave=78}

local names = {}
for name in pairs(scores) do
  names[#names+1] = name
end
table.sort(names)

for _, name in ipairs(names) do
  print(name, scores[name])
end
-- Alice 95, Bob 87, Carol 91, Dave 78 (sorted)

Patrón de valores predeterminados

Un patrón útil consiste en usar una tabla de "valores predeterminados" mediante la metatabla __index. Cuando no se encuentra una clave en la tabla principal, Lua la busca en la tabla de valores predeterminados. Esto permite usar una configuración por capas sin combinar las tablas.

local defaults = {timeout=30, retries=3, verbose=false}
local config = {timeout=60}

setmetatable(config, {__index = defaults})

print(config.timeout)  -- 60  (overridden)
print(config.retries)  -- 3   (from defaults)
print(config.verbose)  -- false (from defaults)

Comprobación rápida

¿Cómo se elimina una clave "x" de la tabla t en Lua?

Repaso: tablas como diccionarios

Aspectos clave:

Notación de punto y de corchetes: t.key == t["key"]
Cualquier valor que no sea nil ni NaN puede ser una clave
Asigne nil para eliminar una clave
Conteo de frecuencias: t[k] = (t[k] or 0) + 1
Recorrido ordenado: recopilar claves → ordenar → recorrer
Use la metatabla __index para los valores predeterminados

Preguntas frecuentes

¿La lección «Tablas como diccionarios» es gratis?

Sí — el texto completo de «Tablas como diccionarios» 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 como diccionarios»?

Utilice claves de tipo string y mixtas para almacenar pares clave-valor. 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 2 de 4.

¿Cuánto tiempo toma la lección «Tablas como diccionarios»?

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

← Volver a Lua Academy