Como funcionam as strings na linguagem Go?

As cadeias em Go são sequências imutáveis de bytes. Elas representam uma "fatia de bytes" ([]byte) com garantia de imutabilidade.

Características principais:

• Imutabilidade: Após a criação, uma cadeia não pode ser alterada. Qualquer operação que pareça modificá-la, na verdade, cria uma nova cadeia.
• Representação: Por padrão, as cadeias em Go representam texto codificado em UTF-8. No entanto, são simplesmente sequências de bytes; a interpretação como UTF-8 ocorre ao trabalhar com runas.
• Runas: Os caracteres Unicode em Go são representados pelo tipo rune, que é um alias para int32. A iteração sobre uma cadeia usando range decodifica automaticamente UTF-8 e fornece as runas e seus índices iniciais em bytes.
• Comprimento: A função len(s) retorna o número de bytes na cadeia, não o número de caracteres (runas). Para obter o número de runas, use utf8.RuneCountInString(s) ou itere com range.
• Concatenação: Para juntar cadeias, usa-se o operador +. Isso cria uma nova cadeia. Para uma concatenação eficiente de muitas cadeias, recomenda-se usar strings.Builder.

Exemplos:

// Declaração de uma cadeia
str := "Hello, 世界"

// Comprimento da cadeia (em bytes)
byteLen := len(str) // 13 (H(1) e(1) l(1) l(1) o(1) ,(1)  (1) 世(3) 界(3))

// Iteração sobre as runas
runeCount := 0
for index, runeValue := range str {
	// index - índice inicial da runa em bytes
	// runeValue - a runa
	runeCount++
	// fmt.Printf("Índice: %d, Runa: %c (Valor: %d)\n", index, runeValue, runeValue)
}
// runeCount - número de runas (9)

// Acesso a um byte por índice
// Atenção: isto é um byte, não um carácter!
// byteAtIndex := str[0] // 'H'
// byteAtIndex := str[7] // Byte inicial do carácter '世'

// Concatenação de cadeias
newStr := str + "!"

// Uso de strings.Builder para concatenação eficiente
// import "strings"
var builder strings.Builder
builder.WriteString("Hello, ")
builder.WriteString("World")
efficientStr := builder.String() // "Hello, World"