Come puoi lavorare con le stringhe nel linguaggio Go…

In Go, le stringhe sono sequenze immutabili di byte.

I principali modi di lavorare con le stringhe:

Creazione:

// Letterale di stringa
s1 := "Hello, Go!"

// Da un slice di byte
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Concatenazione:

s3 := "World"
result := s1 + " " + s3 // Uso dell'operatore +

Per molte concatenazioni, è più efficiente usare strings.Builder:

import "strings"

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

Lunghezza:

In byte:
```
byteLength := len(s1)
```

In caratteri (rune):

runeLength := utf8.RuneCountInString(s1) // Richiede l'import "unicode/utf8"

Accesso ai caratteri (rune) e iterazione: In Go, le stringhe sono composte da byte, ma durante l'iterazione con range vengono decodificate in rune (punti di codice Unicode).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Indice: %d, Rune: %c, Tipo: %T\n", index, runeValue, runeValue)
}
```
L'accesso diretto tramite indice restituisce un byte, non una rune:
```
b := s1[0] // Restituisce il byte 'H'
```

Conversione:

In slice di byte:
```
byteSlice := []byte(s1)
```
In slice di rune:
```
runeSlice := []rune(s1)
```

Pacchetto strings: Fornisce molte funzioni utili per lavorare con le stringhe:
- strings.Contains(s, substr): Verifica la presenza di una sottostringa.
- strings.HasPrefix(s, prefix): Verifica se la stringa inizia con un prefisso.
- strings.HasSuffix(s, suffix): Verifica se la stringa termina con un suffisso.
- strings.Index(s, substr): Trova la prima occorrenza di una sottostringa.
- strings.ReplaceAll(s, old, new): Sostituisce tutte le occorrenze di una sottostringa.
- strings.Split(s, sep): Divide la stringa in base a un separatore.
- strings.Join(a []string, sep string): Unisce un slice di stringhe con un separatore.
- strings.ToLower(s): Converte in minuscolo.
- strings.ToUpper(s): Converte in maiuscolo.
- strings.TrimSpace(s): Rimuove gli spazi bianchi all'inizio e alla fine.
Pacchetto fmt: Per la formattazione e la scansione di stringhe.

Pacchetto strconv: Per convertire stringhe in tipi numerici e viceversa:

import "strconv"

i, err := strconv.Atoi("123") // Da stringa a int
s := strconv.Itoa(i) // Da int a stringa

L'immutabilità delle stringhe è importante e significa che qualsiasi operazione che sembra modificare la stringa (ad esempio, concatenazione o Replace) in realtà crea una nuova stringa.

Come puoi lavorare con le stringhe nel linguaggio Go?