Como formatar strings no Go

Como as strings são muitas vezes feitas de texto escrito, existem muitos casos em que queremos ter um maior controle sobre a aparência das strings a fim de as torná mais legíveis para humanos, usando pontuação, quebras de linha e recuos.

Neste tutorial, vamos revisaremos algumas das maneiras que podemos trabalhar com strings em Go para garantir que todo o texto de saída seja formatado corretamente.

Literais de string

Vamos primeiro ver a diferença entre uma literal de string e um valor de string. Uma literal de string é o que vemos no código fonte de um programa de computador, incluindo os sinais de aspas. Um valor de string é o que vemos quando chamamos a função fmt.Println e executamos o programa.

No programa “Hello, World!”, o literal de string é "Hello, World!", ao passo que o valor de string é Hello, World!, sem as aspas. O valor de string é o que vemos como o resultado em uma janela do terminal quando executamos um programa em Go.

Alguns valores de string, porém, podem ter que incluir aspas, como quando citamos uma fonte. Como as literais de string e os valores de string não são equivalentes, é frequentemente necessário adicionar uma formatação adicional às literais de string para garantir que os valores de string sejam exibidos da maneira que queremos.

Aspas

Como podemos usar o sinal de crase ( ` ) ou aspas duplas (") no Go, é fácil incluí-las em uma string usando aspas duplas dentro de uma string entre sinais de crase:

`Sammy says, "Hello!"`

Alternativamente, para usar o sinal de crase, você pode colocar a string entre aspas duplas:

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

Pela maneira como combinamos os sinais de crase e as aspas duplas, podemos controlar a exibição das aspas e dos sinais de crase dentro de nossas strings.

É importante lembrar que o uso dos sinais de crase no Go cria uma literal de string raw e o uso das aspas duplas cria uma literal de string interpreted. Para aprender mais sobre a diferença entre elas, leia o tutorial Introdução ao trabalho com strings em Go.

Caracteres de escape

Outra maneira de formatar as strings é usar um caractere de escape. Os caracteres de escape são usados para dizer ao código que o caractere seguinte tem um significado especial. Todos os caracteres de escape começam com a tecla de barra invertida (\), combinada com outro caractere dentro de uma string para formatar determinada string de uma certa maneira.

A seguir, apresentamos uma lista de vários dos caracteres de escape comuns:

Vamos usar um caractere de escape para adicionar aspas ao exemplo das aspas acima. Porém, desta vez, usaremos aspas duplas para indicar a string:

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

Output
Sammy says, "Hello!"

Ao usar o caractere de escape \", conseguimos usar usar uma string entre aspas duplas que inclui um texto citado entre aspas duplas.

Podemos usar o caractere de escape \n para quebrar linhas sem ter que pressionar a tecla Enter ou “return”:

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

Output
This string
spans multiple
lines.

Também podemos combinar caracteres de escape. Vamos imprimir uma string de várias linhas e incluir o espaçamento da tabulação em uma lista de itens, por exemplo:

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

Output
1.      Shark
2.      Shrimp
10.     Squid

O recuo horizontal fornecido com o caractere de escape \t garante o alinhamento dentro da segunda coluna, no exemplo anterior, tornando o resultado extremamente legível para humanos.

Os caracteres de escape são usados para adicionar outra formatação às strings que possam ser difíceis ou impossíveis de se alcançar. Sem os caracteres de escape, você não poderia construir a string Sammy says, "I like to use the `fmt` package".

Múltiplas linhas

Imprimir strings em várias linhas pode tornar o texto mais legível para humanos. Com várias linhas, as strings podem ser agrupadas em texto claros e organizadas, formatadas como uma carta ou usadas para manter as quebras de linha de um poema ou de letras de música.

Ao criar strings que abarquem várias linhas, usamos os sinais de crase para delimitar essas strings. Tenha em mente que, embora isso irá preservar as novas linhas abertas, também criará uma nova literal de string raw.

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

Se imprimir esse texto, notará que foi inserida uma linha (com a tecla Enter) no início e outra no final:

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

Para evitar isso, você precisa colocar a primeira linha imediatamente após o sinal de crase e encerrar a última linha também com um sinal de crase.

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

Se precisar criar uma literal de string interpretada, isso pode ser feito com aspas duplas e o operador +, mas será necessário inserir suas próprias quebras de linha.

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

Embora os sinais de crase facilitem a impressão e a leitura de textos longos, se você precisar de uma literal de string interpretada, será necessário usar aspas duplas.

Literais de string bruta

E se não quisermos uma formatação especial dentro de nossas strings? Por exemplo, podemos precisar comparar ou avaliar as strings do código do computador que usem a barra invertida propositadamente; desse modo, não vamos querer que o Go a utilize como um caractere de escape.

Uma literal de string bruta diz ao Go para ignorar toda a formatação dentro de uma string, incluindo os caracteres de escape.

Criamos uma string bruta usando sinais de crase ao redor da string:

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

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

Ao construir uma string bruta, usando sinais de crase ao redor de determinada string, podemos reter as barras invertidas e outros caracteres usados como caracteres de escape.

Conclusão

Este tutorial analisou várias maneiras de formatar o texto no Go através do trabalho com strings. Ao usar técnicas como a de caracteres de escape ou de strings brutas, podemos garantir que as strings do nosso programa serão renderizadas corretamente na tela para que o usuário final consiga ler facilmente todo o texto de saída.