Como pode trabalhar com strings na linguagem Go…

No Go, as strings são sequências imutáveis de bytes.

As principais formas de trabalhar com strings:

Criação:

// Literal de string
s1 := "Hello, Go!"

// A partir de um slice de bytes
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Concatenação:

s3 := "World"
result := s1 + " " + s3 // Uso do operador +

Para muitas concatenações, é mais eficiente usar strings.Builder:

import "strings"

var sb strings.Builder
sb.WriteString("Hello")
sb.WriteString(", ")
sb.WriteString("World!")
result2 := sb.String()

Comprimento:

Em bytes:
```
byteLength := len(s1)
```

Em caracteres (runes):

runeLength := utf8.RuneCountInString(s1) // Requer importação "unicode/utf8"

Acesso a caracteres (runes) e iteração: Em Go, as strings são compostas por bytes, mas ao iterar com range, elas são decodificadas em runas (pontos de código Unicode).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Índice: %d, Rune: %c, Tipo: %T\n", index, runeValue, runeValue)
}
```
O acesso direto por índice retorna um byte, não uma rune:
```
b := s1[0] // Retorna o byte 'H'
```
Conversão:
- Para slice de bytes:
```
byteSlice := []byte(s1)
```
- Para slice de runas:
```
runeSlice := []rune(s1)
```
Pacote strings: Fornece muitas funções úteis para trabalhar com strings:
- strings.Contains(s, substr): Verifica se contém uma substring.
- strings.HasPrefix(s, prefix): Verifica se começa com um prefixo.
- strings.HasSuffix(s, suffix): Verifica se termina com um sufixo.
- strings.Index(s, substr): Busca a primeira ocorrência de uma substring.
- strings.ReplaceAll(s, old, new): Substitui todas as ocorrências de uma substring.
- strings.Split(s, sep): Divide a string por um separador.
- strings.Join(a []string, sep string): Junta um slice de strings com um separador.
- strings.ToLower(s): Converte para minúsculas.
- strings.ToUpper(s): Converte para maiúsculas.
- strings.TrimSpace(s): Remove espaços em branco do início e do fim.
Pacote fmt: Para formatação e leitura de strings.

Pacote strconv: Para converter strings em tipos numéricos e vice-versa.

import "strconv"

i, err := strconv.Atoi("123") // String para int
s := strconv.Itoa(i)         // Int para string

A imutabilidade das strings é importante e significa que qualquer operação que pareça modificar a string (por exemplo, concatenação ou Replace) na verdade cria uma nova string.

Como pode trabalhar com strings na linguagem Go?