Sintaxis: comillas, escapes y corchetes dobles

Lua ofrece dos sintaxis para escribir un literal de cadena y son deliberadamente distintas, no redundantes. Las comillas —simples o dobles, intercambiables— procesan secuencias de escape: el analizador léxico traduce \n a un byte de salto de línea antes de que exista la cadena. Los corchetes dobles no procesan absolutamente nada: lo que escribes es lo que obtienes, byte a byte, saltos de línea incluidos, y su sistema de niveles permite anidar contenido que a su vez contiene corchetes. Elegir mal entre las dos es la causa habitual de que una expresión regular, una ruta de Windows o un fragmento de código incrustado deje de significar lo que creías.

Comillas y secuencias de escape

Las comillas simples y las dobles son equivalentes: no existe la distinción entre cadena interpolada y literal que traen otros lenguajes. La única diferencia práctica es cuál de las dos tienes que escapar dentro del literal, así que se elige la que evite escapes.

Dentro de comillas, la barra invertida introduce una secuencia de escape. Las simbólicas son las clásicas de C: \a alarma, \b retroceso, \f avance de página, \n nueva línea, \r retorno de carro, \t tabulador, \v tabulador vertical, más \\, \" y \' para los propios delimitadores.

local a = 'dijo "hola"'          -- comillas simples fuera, dobles dentro
local b = "dijo \"hola\""        -- equivalente, con escapes
local ruta = "C:\\Users\\ada"    -- cada barra invertida se duplica
local fila = "id\tnombre\n"

Hay dos escapes menos conocidos y muy útiles. La barra invertida al final de línea introduce un salto de línea literal en la cadena y permite continuar en la línea siguiente. Y \z descarta toda la secuencia de espacios en blanco que le sigue, saltos de línea incluidos: sirve para partir un literal largo en el fuente sin introducir ni un byte de más.

local mensaje = "primera linea\
segunda linea"                    -- contiene un salto de linea real

local sql = "SELECT id, nombre \z
             FROM usuarios \z
             WHERE activo = 1"    -- una sola linea sin espacios sobrantes

Escapes numéricos y de Unicode

Un escape decimal \ddd emite un byte cuyo valor es el número indicado, con un máximo de tres dígitos. Su hermano hexadecimal \xXX exige exactamente dos dígitos y es el que deberías preferir por legibilidad. Ambos operan a nivel de byte: no saben nada de codificaciones ni de caracteres.

local nulo = "\0"                 -- Lua admite el byte cero dentro de cadenas
print(#"a\0b")                    --> 3
local esc = "\27[1m"              -- secuencia ANSI en decimal
local esc2 = "\x1b[1m"            -- la misma, en hexadecimal
print(esc == esc2)                --> true

Que el byte cero sea un byte más y no un terminador es una diferencia esencial frente a C: una cadena Lua es una secuencia de bytes con longitud explícita, no una secuencia terminada en nulo. Puedes guardar contenido binario íntegro sin trucos.

El escape \u es de otra naturaleza. Recibe un punto de código Unicode entre llaves, en hexadecimal, y emite su codificación UTF-8, que puede ocupar de uno a cuatro bytes. No introduce un tipo carácter en el lenguaje: sigue produciendo bytes, solo que los correctos.

local euro = "\u{20AC}"           -- tres bytes en UTF-8
print(#euro)                      --> 3
print(euro)                       --> €

local acentuada = "caf\u{e9}"     -- dos bytes para la e acentuada
print(#acentuada)                 --> 5

Cadenas largas y niveles

Un literal largo se abre con [[ y se cierra con ]]. No procesa escapes, admite saltos de línea reales y tiene una única regla peculiar: si el primer carácter tras la apertura es un salto de línea, se descarta. Esa regla existe para que el texto pueda empezar en la línea siguiente sin introducir una línea vacía inicial.

local plantilla = [[
Hola, %s.
Tu ruta es C:\Users\%s
]]                                -- las barras invertidas son literales

Cuando el contenido incluye ]] —código Lua anidado, arrays de otro lenguaje, documentación sobre el propio Lua— se sube de nivel intercalando signos igual entre los corchetes. La apertura y el cierre deben usar el mismo número de signos, así que siempre existe un nivel libre.

flowchart TD
N0[Nivel 0 abre con dos corchetes] --> P0[No sirve si el texto contiene el cierre]
P0 --> N1[Nivel 1 intercala un signo igual]
N1 --> P1[Sirve salvo que el texto tenga ese mismo cierre]
P1 --> N2[Nivel 2 intercala dos signos igual]
N2 --> OK[Elige el nivel mas bajo que no aparezca en los datos]

local doc = [==[
Ejemplo de cadena larga de nivel 0:
local s = [[texto sin escapes]]
Aqui el cierre interno no termina el literal externo.
]==]

La misma sintaxis de niveles gobierna los comentarios largos, que son un guion doble seguido de un literal largo. Subir de nivel en un comentario permite comentar bloques de código que ya contienen comentarios largos, y desactivar un bloque añadiendo o quitando un guion en la línea de apertura es un truco clásico de depuración.

--[[ bloque desactivado
print("no se ejecuta")
--]]

---[[ basta un guion mas arriba para reactivarlo
print("si se ejecuta")
--]]

Hay dos limitaciones que conviene tener presentes antes de abusar del literal largo. La primera es que no admite escapes en absoluto, ni siquiera cuando los necesitas: si tu texto requiere un tabulador real o un byte de control, tendrás que concatenar un fragmento entre comillas o generarlo con string.char. La segunda es que el contenido queda exactamente como se escribió en el fuente, sangrado incluido; un literal largo indentado dentro de una función arrastra esos espacios a cada línea, y eso rompe formatos sensibles a la columna como YAML o Markdown.

local function config()
  return [[
    clave: valor
    otra: valor
  ]]                              -- cada linea lleva cuatro espacios de mas
end

La solución habitual es escribir el literal pegado al margen izquierdo aunque rompa la estética del bloque, o postprocesarlo eliminando el sangrado común. La primera opción es la que verás en el código real: la fidelidad del dato manda sobre la simetría visual del fuente.