Cadenas multilínea en Go: 5 errores fatales y cómo evitarlos

Cadenas multilínea en Go: trampas que acechan incluso a desarrolladores experimentados

Imagine la situación: está escribiendo en Go una consulta SQL, una plantilla JSON o simplemente un mensaje largo para el registro. Intuitivamente presiona Enter para pasar a la siguiente línea y… el compilador muestra un error. ¿Le suena familiar? La pregunta "How do you write multiline strings in Go?" en Stack Overflow ha acumulado miles de visitas por una buena razón. Es uno de esos pequeños detalles que pueden desconcertar incluso a quienes ya dominan la sintaxis del lenguaje.

En este artículo, analizaremos los 5 errores fatales principales al trabajar con cadenas multilínea en Go y mostraremos cómo evitarlos. Aprenderá en qué se diferencian los literales interpretados y los crudos, por qué un espacio adicional puede arruinarle el día y cómo formatear el código correctamente. ¡Comencemos!

Error n.º 1: Usar comillas dobles para texto multilínea

El error más común de los principiantes es intentar escribir una cadena multilínea dentro de comillas dobles ("). En Go, las comillas dobles crean un literal de cadena interpretado. Esto significa que el carácter de nueva línea dentro de ellas está prohibido.

// Este código NO se compilarápackage main

import "fmt"

func main() {    // Error: unexpected newline in string literal    message := "Hola,    mundo!"    fmt.Println(message)}

El compilador de Go es estricto: ve una comilla sin cerrar y un carácter de nueva línea, lo que provoca un error de sintaxis. Recuerde: las comillas dobles son solo para cadenas de una sola línea.

Error n.º 2: Ignorar los literales de cadena crudos (raw string literals)

La solución al problema de las líneas múltiples son los literales de cadena crudos. Se crean con comillas invertidas (`). Dentro de ellos, todos los caracteres se interpretan literalmente, incluidos saltos de línea, tabulaciones e incluso la barra invertida.

// Forma correcta: usamos comillas invertidaspackage main

import "fmt"

func main() {    message := `Hola,mundo!`    fmt.Println(message)}// Salida:// Hola,// mundo!

Esta es la opción ideal para consultas SQL, JSON, plantillas HTML y cualquier otro texto donde la estructura sea importante. Sin embargo, aquí se esconde el siguiente error.

Error n.º 3: Espacios y sangrías sobrantes dentro de cadenas crudas

Cuando escribe código, lo formatea con sangrías para que sea legible. Pero si inserta una cadena multilínea directamente en el cuerpo de una función con sangrías, esas sangrías pasarán a formar parte de la cadena.

// Ejemplo con espacios "sobrantes"package main

import "fmt"

func main() {    query := `        SELECT id, name        FROM users        WHERE active = true    `    fmt.Println(query)}// Salida (observe los espacios iniciales):////         SELECT id, name//         FROM users//         WHERE active = true//     

La primera línea de la salida está vacía (debido al salto de línea después de la comilla de apertura), y cada línea siguiente comienza con 8 espacios. Esto puede romper la lógica si la cadena se usa, por ejemplo, en os.Exec o en una comparación.

¿Cómo evitarlo? Hay dos caminos. El primero es escribir la cadena sin sangrías, pegada al borde:

query := `SELECT id, nameFROM usersWHERE active = true`

El segundo es usar concatenación o strings.TrimSpace. Pero lo más sencillo es acostumbrarse a no poner sangrías dentro de las cadenas crudas si son críticas. Para consultas SQL, esto a menudo no es un problema, pero para registros o mensajes al usuario, puede ser fatal.

Error n.º 4: Olvidar el escape en cadenas crudas

Las cadenas crudas no admiten secuencias de escape. Esto significa que dentro de comillas invertidas son simplemente dos caracteres: una barra invertida y la letra 'n', no un salto de línea.

package main

import "fmt"