Comment pouvez-vous travailler avec des chaînes dans…

En Go, les chaînes sont des séquences immuables d'octets.

Les principales façons de travailler avec les chaînes :

Création :

// Littéral de chaîne
s1 := "Hello, Go!"

// À partir d'un tableau d'octets
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Concaténation :

s3 := "World"
result := s1 + " " + s3 // Utilisation de l'opérateur +

Pour un grand nombre de concaténations, il est plus efficace d'utiliser strings.Builder :

import "strings"

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

Longueur :

En octets :
```
byteLength := len(s1)
```

En caractères (runes) :

runeLength := utf8.RuneCountInString(s1) // Nécessite l'import "unicode/utf8"

Accès aux caractères (runes) et itération : En Go, les chaînes sont composées d'octets, mais lors de l'itération avec range, elles sont décodées en runes (points de code Unicode).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Index : %d, Rune : %c, Type : %T\n", index, runeValue, runeValue)
}
```
L'accès direct par index retourne un octet, pas une rune :
```
b := s1[0] // Retourne l'octet 'H'
```

Conversion :

En slice d'octets :
```
byteSlice := []byte(s1)
```
En slice de runes :
```
runeSlice := []rune(s1)
```

Package strings : Fournit de nombreuses fonctions utiles pour travailler avec les chaînes :
- strings.Contains(s, substr) : Vérifie si une sous-chaîne est présente.
- strings.HasPrefix(s, prefix) : Vérifie si la chaîne commence par un préfixe.
- strings.HasSuffix(s, suffix) : Vérifie si la chaîne se termine par un suffixe.
- strings.Index(s, substr) : Recherche la première occurrence d'une sous-chaîne.
- strings.ReplaceAll(s, old, new) : Remplace toutes les occurrences d'une sous-chaîne.
- strings.Split(s, sep) : Divise la chaîne selon un séparateur.
- strings.Join(a []string, sep string) : Concatène un slice de chaînes avec un séparateur.
- strings.ToLower(s) : Convertit en minuscules.
- strings.ToUpper(s) : Convertit en majuscules.
- strings.TrimSpace(s) : Supprime les espaces en début et fin.
Package fmt : Pour le formatage et la lecture de chaînes.

Package strconv : Pour convertir des chaînes en types numériques et vice versa.

import "strconv"

i, err := strconv.Atoi("123") // De string à int
s := strconv.Itoa(i)         // De int à string

L'immutabilité des chaînes est importante et signifie que toute opération qui semble modifier la chaîne (par exemple, la concaténation ou Replace) crée en réalité une nouvelle chaîne.

Comment pouvez-vous travailler avec des chaînes dans le langage Go?