La biblioteca table

La biblioteca table es diminuta: siete funciones que caben en media pantalla de documentación. Esa brevedad engaña, porque todas comparten un contrato tácito que el manual enuncia una sola vez y del que depende por completo su corrección: operan sobre secuencias, es decir, sobre tablas cuyas claves enteras van de 1 a un cierto n sin ausencia alguna. En cuanto ese contrato se rompe, ninguna de ellas falla de forma ruidosa; simplemente empieza a devolver resultados que dependen de la disposición interna de la memoria. Este apartado enseña las siete y, sobre todo, dónde está su frontera.

Insertar, quitar y mover

table.insert admite dos formas. Con dos argumentos añade al final; con tres, inserta en la posición indicada y desplaza hacia la derecha todo lo que había desde ahí. table.remove es su simétrica: devuelve el elemento extraído y compacta el hueco.

local t = { "a", "b", "c" }

table.insert(t, "d")        -- al final: coste constante amortizado
table.insert(t, 1, "z")     -- en la posicion 1: desplaza n elementos
--> { "z", "a", "b", "c", "d" }

local ultimo = table.remove(t)      -- quita y devuelve el ultimo
local primero = table.remove(t, 1)  -- quita el primero y compacta
print(ultimo, primero)              --> d   z

table.move es la más reciente y la menos conocida: copia un rango de una secuencia a otra posición, incluso dentro de la misma tabla, y maneja correctamente los solapamientos. Es la primitiva sobre la que se pueden construir rotaciones, desplazamientos e inserciones en bloque sin bucles a mano.

local origen = { 1, 2, 3, 4, 5 }
local destino = {}
table.move(origen, 2, 4, 1, destino)   --> destino = { 2, 3, 4 }
table.move(origen, 1, 3, 3)            --> origen  = { 1, 2, 1, 2, 3 }

Concatenar y ordenar

table.concat une los elementos de una secuencia en una sola cadena, con separador opcional y rango opcional. Es la forma canónica de construir texto en Lua: acumular fragmentos en una tabla y concatenar una sola vez al final evita la explosión cuadrática de crear una cadena nueva en cada paso, porque las cadenas de Lua son inmutables e internadas.

local partes = { "uno", "dos", "tres" }
print(table.concat(partes, ", "))        --> uno, dos, tres
print(table.concat(partes, " | ", 2, 3)) --> dos | tres

El rango opcional es más útil de lo que parece: permite reutilizar un único vector de fragmentos como acumulador reiniciable, uniendo solo la porción viva y evitando asignar una tabla nueva en cada pasada.

local buf, n = {}, 0
local function emitir(s) n = n + 1; buf[n] = s end

emitir("cabecera"); emitir("cuerpo"); emitir("pie")
local salida = table.concat(buf, "\n", 1, n)
n = 0   -- reinicio sin reasignar: la tabla se reaprovecha entera

table.sort ordena en el sitio, sin devolver nada, mediante una variante de ordenación rápida. No es estable: elementos considerados equivalentes pueden quedar en cualquier orden relativo entre ellos. El segundo argumento es una función de comparación que debe responder si el primer elemento va estrictamente antes que el segundo.

local nombres = { "carla", "ana", "beto" }
table.sort(nombres)                                  -- orden natural
table.sort(nombres, function(a, b) return a > b end) -- descendente

Empaquetar y desempaquetar

table.unpack convierte una secuencia en una lista de valores múltiples, y table.pack hace el camino inverso añadiendo un campo con el recuento real. Juntas son el puente entre el mundo de las tablas y el de las funciones variádicas.

local args = { 3, 5 }
print(math.max(table.unpack(args)))   --> 5

local p = table.pack(1, nil, 3)
print(p.n, #p)   --> 3   y un valor no fiable para la longitud

El campo con el recuento existe precisamente porque el operador de longitud deja de ser fiable en presencia de agujeros. Por eso el idioma robusto para reenviar argumentos arbitrarios, incluidos los ausentes, es empaquetar con recuento y desempaquetar indicando el rango completo de forma explícita:

local function envolver(f)
  return function(...)
    local p = table.pack(...)
    -- aqui se podria registrar, validar o transformar p
    return f(table.unpack(p, 1, p.n))   -- rango explicito: conserva los ausentes
  end
end

table.unpack admite siempre un índice inicial y uno final; sin ellos usa 1 y la longitud, que es justo el valor poco fiable que queremos evitar. Conviene recordar además que el número de valores devueltos por esta función está acotado por el tamaño de la pila del intérprete: desempaquetar una secuencia de cientos de miles de elementos no es una operación válida, sino una vía rápida al desbordamiento.

flowchart TD
A[Tabla con un agujero] --> B[Operador de longitud]
A --> C[Insertar y quitar]
A --> D[Concatenar]
A --> E[Ordenar]
B --> B1[Devuelve cualquier frontera valida]
C --> C1[Comportamiento indefinido]
D --> D1[Error al intentar unir un valor ausente]
E --> E1[Error de comparacion con valor ausente]

Qué ocurre con un agujero

Un agujero es un valor ausente intercalado entre claves enteras. Basta uno para que la tabla deje de ser secuencia, y a partir de ahí cada función de la biblioteca se comporta de una manera distinta:

La lección práctica es que en Lua no se borra un elemento intermedio asignando el valor ausente. Se borra con table.remove, que compacta, o bien se marca con un centinela y se compacta después en una sola pasada.