Como são estruturadas as strings na linguagem de programação Go?

Uma string em Go é uma sequência imutável de bytes.

Características principais:

• Imutabilidade: após a criação, a string não pode ser alterada.
• Representação: é armazenada como um ponteiro e um comprimento. O ponteiro aponta para o primeiro byte da sequência na memória. O comprimento é a quantidade de bytes.
• Codificação: as strings em Go não contêm informações sobre a codificação. São frequentemente usadas para armazenar UTF-8, mas podem conter quaisquer bytes.
• Iteração por bytes: o ciclo for index, value range string ao iterar sobre uma string retorna o índice e a rune (int32), não o byte.
• Iteração por runas: uma rune representa um ponto de código Unicode. Go usa UTF-8, portanto uma rune pode ocupar de 1 a 4 bytes.
• Obter uma substring: a operação de corte string[start:end] cria uma nova string que aponta para a mesma seção de memória, mas com limites diferentes.

Exemplos:

// Declaração e inicialização
var s string
s = "Привет" // Literal de string em Go - sequência de bytes,
             // geralmente interpretada como UTF-8

// Comprimento da string em bytes
byteLength := len(s) // 12, pois "П", "р", "и", "в", "е", "т" são caracteres multibyte em UTF-8

// Iteração por runas
runeCount := 0
for index, runeValue := range s {
    // index - índice do início da rune em bytes
    // runeValue - valor da rune (int32)
    _ = index // Uso de um identificador anônimo _ para variável não utilizada
    // fmt.Printf("Índice: %d, Rune: %c (U+%04X)\n", index, runeValue, runeValue)
    runeCount++
}
// runeCount será 6

// Iteração por bytes
byteCount := 0
for i := 0; i < len(s); i++ {
    // s[i] - byte no índice i
    _ = s[i] // Uso de um identificador anônimo
    // fmt.Printf("Byte no índice %d: %d\n", i, s[i])
    byteCount++
}
// byteCount será 12

// Obter uma substring (corte de bytes)
// Importante: o corte de bytes pode quebrar uma rune multibyte
// sub := s[0:5] // Isto pode ser uma sequência UTF-8 inválida

// Uso de pacotes strings ou unicode/utf8 para trabalhar de forma segura com runas

Comparação com corte de bytes ([]byte):

Característica	String	[]byte
Mutabilidade	Não	Sim
Representação	Ponteiro + Comprimento	Ponteiro + Comprimento + Capacidade
Tipo	Primitivo embutido	Slice (fatia)
Uso	Texto imutável	Dados modificáveis (bytes)

Conversão entre string e []byte:

// string -> []byte
byteSlice := []byte(s)

// []byte -> string
newString := string(byteSlice)