Cum poți lucra cu șiruri de caractere în limbajul Go…

În Go, șirurile de caractere sunt secvențe imuabile de octeți.

Principalele moduri de a lucra cu șiruri de caractere:

Creare:

// Literal de șir
s1 := "Hello, Go!"

// Dintr-un slice de octeți
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Concatenare:

s3 := "World"
result := s1 + " " + s3 // Utilizarea operatorului +

Pentru un număr mare de concatenări, este mai eficient să folosiți strings.Builder:

import "strings"

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

Lungime:

În octeți:
```
byteLength := len(s1)
```

În caractere (rune):

runeLength := utf8.RuneCountInString(s1) // Necesită importul "unicode/utf8"

Acces la caractere (rune) și iterare: În Go, șirurile de caractere sunt formate din octeți, dar la iterare cu range sunt decodificate în rune (puncte de cod Unicode).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Index: %d, Rune: %c, Tip: %T\n", index, runeValue, runeValue)
}
```
Accesul direct după index returnează un octet, nu o rune:
```
b := s1[0] // Returnează octetul 'H'
```

Conversie:

În slice de octeți:
```
byteSlice := []byte(s1)
```
În slice de rune:
```
runeSlice := []rune(s1)
```

Pachetul strings: Oferă multe funcții utile pentru lucrul cu șiruri de caractere:
- strings.Contains(s, substr): Verifică dacă conține o subșir.
- strings.HasPrefix(s, prefix): Verifică dacă începe cu un prefix.
- strings.HasSuffix(s, suffix): Verifică dacă se termină cu un sufix.
- strings.Index(s, substr): Caută prima apariție a unei subșir.
- strings.ReplaceAll(s, old, new): Înlocuiește toate aparițiile.
- strings.Split(s, sep): Împarte șirul după un separator.
- strings.Join(a []string, sep string): Unește un slice de șiruri.
- strings.ToLower(s): Convertește în litere mici.
- strings.ToUpper(s): Convertește în litere mari.
- strings.TrimSpace(s): Elimină spațiile albe de la început și sfârșit.
Pachetul fmt: Pentru afișare formatată și citire.

Pachetul strconv: Pentru conversia șirurilor în tipuri numerice și invers:

import "strconv"

i, err := strconv.Atoi("123") // Din string în int
s := strconv.Itoa(i) // Din int în string

Imutabilitatea șirurilor de caractere este importantă și înseamnă că orice operație care pare să modifice șirul (de exemplu, concatenarea sau Replace) creează de fapt un șir nou.

Cum poți lucra cu șiruri de caractere în limbajul Go?