Una estructura para todo

Casi todos los lenguajes reparten un catálogo de estructuras: listas, tuplas, diccionarios, conjuntos, registros, clases, espacios de nombres. Lua reparte una. La tabla es el único tipo compuesto del lenguaje, y no por carencia: es una decisión de diseño que atraviesa el intérprete entero, desde la representación en memoria hasta la semántica de los módulos y del propio entorno global. Entender que array, objeto, módulo y conjunto no son cuatro cosas distintas sino cuatro maneras de usar la misma cosa es el salto conceptual que separa a quien escribe Lua de quien lo traduce desde otro lenguaje.

Seis papeles, un solo tipo

Lo que sigue son seis usos que en otros lenguajes exigirían seis tipos distintos. En Lua son el mismo valor, creado con el mismo constructor y consultado con el mismo operador de indexación:

-- 1. Array (o secuencia): claves enteras consecutivas desde 1
local dias = { "lunes", "martes", "miercoles" }

-- 2. Diccionario: claves de cadena, valores arbitrarios
local config = { ancho = 80, alto = 24, tema = "oscuro" }

-- 3. Objeto: datos y funciones que operan sobre esos datos
local contador = { n = 0 }
function contador:incr() self.n = self.n + 1 end

-- 4. Módulo: una tabla que se devuelve al final del archivo
local M = {}
function M.saluda(quien) return "hola " .. quien end
return M

-- 5. Conjunto: las claves son los elementos, el valor es solo un testigo
local vocales = { a = true, e = true, i = true, o = true, u = true }

-- 6. Espacio de nombres: el propio entorno global es una tabla
_G.print == print  --> true

La consulta a un campo inexistente no es un error: devuelve el valor ausente. Eso hace que preguntar por algo que no está sea barato y silencioso, y explica por qué en Lua los registros no necesitan declararse ni los objetos anunciar sus campos.

local t = { a = 1 }
print(t.a, t.b, t[1])   --> 1   nil   nil
t.b = 2                 -- crear un campo es asignarlo, no declararlo

No hay conversión entre estos usos porque no hay nada que convertir. Una misma tabla puede ser simultáneamente array y diccionario: t[1] y t.nombre conviven sin fricción porque, para Lua, t.nombre es puro azúcar de t["nombre"]. La distinción array frente a diccionario no existe en el tipo; existe únicamente en tu cabeza y en la disciplina con la que uses las claves.

Por dentro: dos mitades en un mismo objeto

La implementación de referencia no guarda todas las claves de la misma forma. Cada tabla contiene dos almacenes cooperando bajo una única fachada:

flowchart TD
T[Una tabla de Lua] --> S[Parte secuencia]
T --> H[Parte hash]
T --> M[Metatabla opcional]
S --> S1[Claves enteras densas desde 1]
S --> S2[Acceso por indice directo]
H --> H1[Cadenas booleanos flotantes funciones tablas]
H --> H2[Acceso por dispersion con encadenamiento]
M --> M1[Comportamiento ante busquedas fallidas]

La parte secuencia es un vector de C indexado por posición: si las claves enteras son densas y empiezan en 1, el acceso es aritmética de punteros, sin dispersión ni comparación de claves. La parte hash es una tabla de dispersión con encadenamiento interno para todo lo demás. Lua decide en tiempo de ejecución, al redimensionar, cuántas claves enteras merecen migrar al vector; el criterio es que más de la mitad de las posiciones del vector queden ocupadas.

Esta arquitectura tiene dos consecuencias que se notan en programas reales. La primera es que rellenar una tabla en orden creciente desde el índice 1 es sensiblemente más rápido que rellenarla en orden aleatorio o desde índices altos, porque en el primer caso el redimensionado migra las claves al vector y en el segundo se quedan en la parte dispersa pagando una función de dispersión por acceso. La segunda es que el orden en que pairs visita las claves no es el orden de inserción ni ningún otro orden estable: es el orden físico de los dos almacenes, y puede cambiar entre ejecuciones o entre versiones del intérprete. Si tu programa necesita un orden, debes imponerlo tú con una secuencia auxiliar de claves ordenadas.

La tabla debajo de todo lo demás

Los tres mecanismos que en otros lenguajes forman parte del núcleo sintáctico son, en Lua, meros usos de la tabla. No hay palabra reservada para ninguno de ellos:

-- Objetos: los metodos viven en una tabla que hace de clase
local Punto = {}
Punto.__index = Punto

function Punto.nuevo(x, y)
  return setmetatable({ x = x, y = y }, Punto)
end

function Punto:norma()
  return math.sqrt(self.x ^ 2 + self.y ^ 2)
end

-- Modulos: require devuelve la tabla que el archivo retorno, y la cachea
local geo = require("geometria")
print(package.loaded["geometria"] == geo)   --> true

-- Entorno: las globales viven en una tabla que el programa puede sustituir
local seguro = { print = print, pairs = pairs, tostring = tostring }
-- ejecutar codigo no confiable con "seguro" como entorno lo aisla del resto

Merece la pena detenerse en la tercera. En casi todos los lenguajes, aislar código ajeno exige un intérprete separado, un proceso, un contenedor o un mecanismo de permisos empotrado en el runtime. En Lua basta con darle al fragmento sospechoso una tabla distinta como entorno global: si esa tabla no contiene os ni io, el código simplemente no tiene manera de nombrar el sistema de archivos. El sandbox no es una característica del lenguaje; es un corolario de que las globales viven en una tabla ordinaria.

La economía de una sola decisión

Hay una consecuencia práctica de todo esto que conviene aceptar pronto: en Lua el diseño de datos es diseño de convenciones. Ningún tipo te va a impedir mezclar una secuencia con campos con nombre, ni te va a avisar de que un módulo acabó recibiendo una clave numérica, ni va a distinguir un conjunto de un diccionario. Lo que en otros lenguajes sostiene el compilador, aquí lo sostienen la disciplina del equipo y la claridad de los nombres.

Conviene fijar el vocabulario que usaremos en el resto del nivel. Una secuencia es una tabla cuyas claves son exactamente los enteros de 1 a n sin ausencias. Un registro es una tabla usada con claves de cadena fijas y conocidas. Un agujero es un nil intercalado entre claves enteras, y basta uno para que la tabla deje de ser secuencia y para que buena parte de la biblioteca estándar pase a tener comportamiento indefinido sobre ella.