La cadena como valor inmutable

En Lua una cadena no es un contenedor que puedas modificar: es un valor, tan inmutable como el número siete. No existe ninguna operación que altere una cadena ya creada; existen operaciones que fabrican otra. Esa decisión, que parece un detalle de biblioteca, gobierna el rendimiento de casi todo el código de texto que vas a escribir: explica por qué concatenar dentro de un bucle degrada a coste cuadrático, por qué el recolector de basura acaba siendo el protagonista silencioso de tus rutinas de formateo, y por qué el idioma canónico del lenguaje consiste en acumular fragmentos en una tabla y unirlos una sola vez al final.

Un valor, no un objeto

Una cadena en Lua se comporta exactamente como un número: se copia por valor desde el punto de vista semántico, se compara por contenido y no admite mutación in situ. No hay s[3] = "x", no hay método que recorte el original, no hay buffer al que añadir. Todo lo que parece modificación es en realidad construcción de un valor nuevo que luego reasignas a la variable.

local s = "hola"
local t = s          -- t y s designan el mismo valor
s = s .. " mundo"    -- no muta nada: crea otra cadena y la asigna a s

print(t)             --> hola
print(s)             --> hola mundo

La variable s cambió; la cadena "hola" no. Sigue viva mientras t la referencie y desaparecerá cuando nadie la nombre. Esta propiedad tiene tres consecuencias que conviene tener presentes desde el principio.

La primera es que la longitud es un dato almacenado, no calculado: el operador # sobre una cadena es de coste constante porque el objeto interno guarda su tamaño. La segunda es que una cadena puede usarse como clave de tabla sin ningún riesgo de que alguien la modifique a tus espaldas y corrompa el hash. La tercera, la que más duele en producción, es que cada operación textual es una asignación de memoria y, por tanto, trabajo futuro para el recolector.

local nombre = "ada"
print(#nombre)                    --> 3
print(nombre:upper())             --> ADA  (cadena nueva)
print(nombre)                     --> ada  (intacta)
print(("x"):rep(3))               --> xxx  (cadena nueva)

El operador de concatenación merece una mirada propia. Se escribe con dos puntos consecutivos, es asociativo por la derecha y acepta también números, que convierte a su representación textual antes de unirlos. Esa coerción es cómoda y a la vez traicionera: hace que una expresión mal escrita produzca texto en lugar de un error, y esconde la conversión numérica justo donde el formato importa.

print(1 .. 2)                     --> "12"  (coercion silenciosa)
print(type(1 .. 2))               --> string
print(0.1 + 0.2 .. "")            --> "0.3" con la precision por defecto

-- El espacio antes de los dos puntos no es opcional tras un numero:
-- 1..2 seria un numero mal formado para el analizador lexico.

Cuando uno de los operandos no es cadena ni número, Lua consulta el metamétodo __concat de su metatabla antes de rendirse con un error. Es el punto de extensión que permite que tus objetos participen en expresiones textuales, y conviene usarlo con moderación: un __concat que construye cadenas intermedias reintroduce por la puerta de atrás exactamente el problema que este nivel enseña a evitar.

local Ruta = {}
Ruta.__index = Ruta
Ruta.__concat = function(a, b)
  local ta = type(a) == "table" and a.valor or a
  local tb = type(b) == "table" and b.valor or b
  return setmetatable({valor = ta .. "/" .. tb}, Ruta)
end
Ruta.__tostring = function(r) return r.valor end

local raiz = setmetatable({valor = "/srv"}, Ruta)
print(tostring(raiz .. "www" .. "index.html"))   --> /srv/www/index.html

El error clásico: concatenar dentro de un bucle

Este es el fallo de rendimiento más repetido en código Lua, y no porque el programador sea descuidado, sino porque el código parece correcto y en lenguajes con cadenas mutables o con optimización de acumuladores lo sería.

-- Antipatrón: coste cuadrático en tiempo y en basura generada
local buf = ""
for i = 1, 100000 do
  buf = buf .. tostring(i) .. ","
end

Analicemos el coste. En la iteración i, la cadena acumulada mide aproximadamente i veces k bytes, siendo k la longitud media de cada fragmento. Concatenar exige reservar un bloque nuevo y copiar íntegramente lo ya acumulado. Sumando sobre las n vueltas, el número de bytes copiados crece con el cuadrado de n. Con cien mil iteraciones eso significa del orden de decenas de miles de millones de bytes movidos, y además unas doscientas mil cadenas intermedias condenadas a morir en cuanto se crea la siguiente.

flowchart LR
A[buffer de 1000 bytes] --> B[copia 1000 mas 6]
B --> C[copia 1006 mas 6]
C --> D[copia 1012 mas 6]
D --> E[cada vuelta copia todo lo anterior]
E --> F[basura intermedia proporcional a n al cuadrado]

El patrón acumulador

La solución idiomática invierte el orden del trabajo: primero se recogen los fragmentos en una tabla —que sí es mutable y crece de forma amortizada— y solo al final se ensambla la cadena definitiva con table.concat.

local partes = {}
for i = 1, 100000 do
  partes[#partes + 1] = tostring(i)
end
local buf = table.concat(partes, ",")

table.concat hace dos pasadas: una para sumar las longitudes de todos los fragmentos y otra para copiarlos en un único bloque del tamaño exacto. El resultado es lineal en el total de bytes y genera una sola cadena final en lugar de doscientas mil intermedias. En cargas reales la diferencia entre ambas versiones se mide en órdenes de magnitud, no en porcentajes.

Conviene, sin embargo, no convertir la regla en superstición. La máquina virtual de Lua compila una expresión con varias concatenaciones encadenadas a una única instrucción OP_CONCAT que opera sobre un rango de registros: a .. b .. c .. d en una sola expresión reserva un bloque, no tres. El problema nunca fue el operador, sino repetirlo a lo largo de iteraciones sucesivas con un acumulado que crece.

-- Perfectamente correcto: una expresión, una asignación de memoria
local linea = nombre .. ": " .. valor .. " (" .. unidad .. ")"

-- Igual de correcto y más legible cuando hay formato de por medio
local linea2 = string.format("%s: %s (%s)", nombre, valor, unidad)

La heurística práctica es sencilla: si el número de piezas se conoce al escribir el código, concatena o formatea directamente; si el número de piezas depende de un bucle o de datos de entrada, acumula en una tabla. Cuando el volumen es realmente grande y el consumo de memoria de la tabla intermedia preocupa, la alternativa es vaciar el acumulador por bloques hacia la salida.

local partes, salida = {}, {}
for i = 1, 1000000 do
  partes[#partes + 1] = tostring(i)
  if #partes == 4096 then                  -- vaciado periódico
    salida[#salida + 1] = table.concat(partes, ",")
    partes = {}
  end
end
salida[#salida + 1] = table.concat(partes, ",")
local texto = table.concat(salida, ",")