Cómo dar formato a cadenas en Go

Debido a que las cadenas suelen estar compuestas de texto escrito, hay muchos casos en los que posiblemente queramos tener un control más amplio sobre su apariencia para que los humanos puedan leerlas con mayor facilidad mediante puntuación, saltos de línea y sangrías.

En este tutorial, repasaremos algunas de las maneras en las que podemos trabajar con las cadenas de Go para asegurarnos de que todo el texto de salida tenga el formato correcto.

Literales de cadena

Primero, diferenciaremos un literal de cadena de un valor de cadena. Un literal de cadena es lo que vemos en el código fuente de un programa informático, incluidas las comillas. Un valor de cadena es lo que vemos cuando invocamos la función fmt.Println y ejecutamos el programa.

En el programa “Hello, World!”, el literal de cadena es “Hello, World!” y el valor de cadena es Hello, World! sin las comillas. El valor de cadena es lo que vemos como resultado en una ventana del terminal cuando ejecutamos un programa de Go.

Sin embargo, es posible que para algunos valores de cadena se deban incluir comillas, como cuando citamos a una fuente. Debido a que los literales y los valores de cadena no son equivalentes, a menudo es necesario añadir formato adicional a los literales para permitir que los valores se muestren de la manera deseada.

Citas

Debido a que en Go podemos usar comillas invertidas (`) o comillas dobles ("), es sencillo insertar citas en una cadena usando comillas dobles dentro de una cadena encerrada entre comillas invertidas:

`Sammy says, "Hello!"`

Alternativamente, para usar comillas invertidas se puede encerrar la cadena entre comillas dobles:

"Sammy likes the `fmt` package for formatting strings.."

Al combinar comillas invertidas y dobles, podemos controlar la visualización de las comillas en nuestras cadenas.

Es importante recordar que las comillas inversas en Go crean un literal de cadena raw y que las comillas dobles crean un literal de cadena interpreted. Para obtener más información sobre esta diferencia, lea el tutorial Introducción al trabajo con cadenas en Go.

Caracteres de escape

Otra opción para dar formato a las cadenas es usar un carácter de escape. Los caracteres de escape se utilizan para indicar al código que el siguiente carácter tiene un significado especial. Los caracteres de escape comienzan con una barra diagonal inversa (\) en combinación con otro carácter dentro de una cadena para dar cierto formato a la cadena.

Esta es una lista de varios de los caracteres de escape comunes:

Emplearemos un carácter de escape para añadir las comillas al ejemplo de comillas anteriores, pero esta vez usaremos comillas dobles para denotar la cadena:

fmt.Println("Sammy says, \"Hello!\"")

Output
Sammy says, "Hello!"

Al usar el carácter de escape \", podemos usar comillas dobles para encerrar una cadena que incluya texto entre comillas dobles.

Podemos usar el carácter de escape \n para insertar saltos de línea sin tener pulsar la tecla Intro:

fmt.Println("This string\nspans multiple\nlines.")

Output
This string
spans multiple
lines.

También podemos combinar caracteres de escape. Imprimiremos una cadena de varias líneas e incluiremos sangrías para una lista detallada, por ejemplo:

fmt.Println("1.\tShark\n2.\tShrimp\n10.\tSquid")

Output
1.      Shark
2.      Shrimp
10.     Squid

La sangría que cuenta con el carácter de escape \t garantiza la alineación dentro de la segunda columna del ejemplo anterior, lo cual hace que el resultado sea sumamente fácil de leer para los seres humanos.

Los caracteres de escape se utilizan para añadir formato a cadenas que pueden ser difíciles, o imposibles, de lograr. Sin caracteres de escape, no podría crear la cadena Sammy says, "I like to use the `fmt` package".

Líneas múltiples

La impresión de cadenas en varias líneas puede facilitar la lectura del texto para los humanos. Con varias líneas, las cadenas pueden agruparse en un texto prolijo y ordenado, recibir formato de carta o usarse para mantener los saltos de línea de un poema o la letra de una canción.

Para crear una cadena que abarque varias líneas, se usan comillas invertidas para encerrar la cadena. Tenga en cuenta que, si bien esto preserva los saltos de línea, también crea un literal de cadena raw.

`
This string is on
multiple lines
within three single
quotes on either side.
`

Al imprimir esto, notará que hay un salto al principio y otro al final:

Output
This string is on
multiple lines
within three single
quotes on either side.

Para evitar que esto suceda, debe disponer la primera línea inmediatamente después de la comilla invertida y terminar la última con otra comilla invertida.

`This string is on
multiple lines
within three single
quotes on either side.`

Si debe crear un literal de cadena interpretado, puede hacerlo con comillas dobles y el operador +, pero tendrá que insertar sus propios saltos de línea.

"This string is on\n" +
"multiple lines\n" +
"within three single\n" +
"quotes on either side."

Si bien las comillas invertidas pueden facilitar la impresión y la lectura de textos largos, si necesita un literal de cadena interpretado, tendrá que usar comillas dobles.

Literales de cadena sin formato

¿Qué sucede si no deseamos que nuestras cadenas tengan un formato especial? Por ejemplo, es posible que debamos comparar o evaluar cadenas de código informático que utilizan la barra diagonal inversa a propósito, por lo cual no nos convendrá que Go la utilice como carácter de escape.

Un literal de cadena raw indica a Go que ignore todo el formato de una cadena, incluidos los caracteres de escape.

Creamos una cadena sin formato rodeándola con comillas invertidas:

fmt.Println(`Sammy says,\"The balloon\'s color is red.\"`)

Output
Sammy says,\"The balloon\'s color is red.\"

Al crear una cadena sin formato encerrada entre comillas invertidas, podemos mantener las barras diagonales inversas y otros caracteres que se utilizan como caracteres de escape.

Conclusión

En este tutorial, repasamos varias maneras de dar formato a texto en Go al trabajar con cadenas. Al usar técnicas como los caracteres de escape o las cadenas sin formato, podemos garantizar que las cadenas de nuestro programa se representen de forma correcta en la pantalla para que el usuario final pueda leer fácilmente todo el texto de salida.