Chaînes en Golang : Split, Join, Contains, Replace et plus

Une chaîne Go est une séquence immuable d'octets, normalement du texte UTF-8. Les opérateurs travaillent sur la chaîne elle-même (+, ==, <, indexation, découpage), et tout le reste se trouve dans le package standard strings.

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "apple,banana,cherry"

	parts := strings.Split(csv, ",")
	fmt.Println(parts, len(parts))

	fmt.Println(strings.Join(parts, " | "))
	fmt.Println(strings.Contains(csv, "nan"))
	fmt.Println(strings.ReplaceAll(csv, ",", ";"))
	fmt.Println(strings.ToUpper(parts[0]))
	fmt.Println(strings.TrimSpace("   padded   ") + "!")
}

Découper des chaînes

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,,c", ","))
	fmt.Printf("%q\n", strings.Split("", ","))
	fmt.Printf("%q\n", strings.Fields("  one  two\tthree\n"))
	fmt.Printf("%q\n", strings.SplitN("k=v=x", "=", 2))
	fmt.Printf("%q\n", strings.Split("go", ""))

	key, value, found := strings.Cut("timeout=30s", "=")
	fmt.Println(key, value, found)
}

Le cas Split("", ",") piège les gens : une entrée vide donne une slice de longueur 1, pas 0. Pour découper une saisie utilisateur, Fields ou un test préalable s == "" évite un élément vide fantôme.

strings.Cut est la façon la plus propre de découper key=value, user@host et autres paires. Go 1.24 a aussi ajouté des versions itérateurs, strings.SplitSeq et strings.FieldsSeq, qui fournissent les parties une par une sans construire de slice.

Rechercher

Toutes les recherches sont sensibles à la casse sauf EqualFold. Pour chercher sans tenir compte de la casse, passez les deux côtés en minuscules, ou utilisez EqualFold pour comparer des chaînes entières.

Transformer

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher!  "

	fmt.Printf("%q\n", strings.TrimSpace(s))
	fmt.Printf("%q\n", strings.Trim("--go--", "-"))
	fmt.Printf("%q\n", strings.TrimPrefix("v1.2.3", "v"))
	fmt.Printf("%q\n", strings.TrimSuffix("report.pdf", ".pdf"))
	fmt.Printf("%q\n", strings.TrimLeft("xxhixx", "x"))

	fmt.Println(strings.ToLower("MiXeD"), strings.ToUpper("mixed"))
	fmt.Println(strings.Replace("a-b-c-d", "-", "+", 2))
	fmt.Println(strings.ReplaceAll("a-b-c-d", "-", ""))
	fmt.Println(strings.Repeat("=", 20))
}

Un piège : Trim, TrimLeft et TrimRight prennent un ensemble de caractères, pas un préfixe. strings.TrimLeft("abcab", "ab") retire tous les a et b en tête et renvoie "cab". Pour retirer un préfixe ou un suffixe exact, utilisez TrimPrefix et TrimSuffix.

Concaténation et strings.Builder

+ assemble des chaînes, et fmt.Sprintf formate des valeurs en une chaîne. Les deux allouent une nouvelle chaîne à chaque fois, parce que les chaînes sont immuables. C'est acceptable pour quelques opérations et lent dans une boucle, où chaque += recopie tout ce qui a déjà été construit. Utilisez plutôt strings.Builder :

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 1; i <= 5; i++ {
		fmt.Fprintf(&b, "row %d", i)
		if i < 5 {
			b.WriteString(", ")
		}
	}
	fmt.Println(b.String())
	fmt.Println("length:", b.Len())

	// joining a slice is simpler still
	names := []string{"Ana", "Ben", "Chen"}
	fmt.Println("Hello " + strings.Join(names, ", "))
}

Un strings.Builder à zéro est prêt à l'emploi. Il implémente io.Writer, donc fmt.Fprintf écrit directement dedans. Appelez d'abord b.Grow(n) si vous connaissez à peu près la taille du résultat. Ne copiez pas un Builder après avoir écrit dedans ; passez un pointeur.

Chaînes multilignes et chaînes brutes

Go a deux sortes de littéraux de chaîne :

package main

import "fmt"

func main() {
	interpreted := "line one\nline two\ttabbed \"quoted\""
	raw := `C:\Users\ana\notes.txt
second line, \n stays literal`

	fmt.Println(interpreted)
	fmt.Println(raw)

	query := `
SELECT id, name
FROM users
WHERE active = true`
	fmt.Println(query)
}

Les chaînes entre guillemets doubles interprètent les échappements (\n, \t, \", \\, \u00e9) et doivent tenir sur une ligne. Les chaînes brutes entre accents graves prennent tout littéralement, retours à la ligne compris, ce qui en fait la façon d'écrire des chaînes multilignes, des expressions régulières, du JSON et des chemins Windows. Une chaîne brute ne peut pas contenir d'accent grave, et les retours chariot qu'elle contient sont supprimés. Notez que la requête ci-dessus commence par un retour à la ligne, puisque le littéral démarre juste après l'accent grave ouvrant.

Longueur, indexation et sous-chaînes

len(s) est le nombre d'octets. s[i] est un octet, et s[i:j] est une sous-chaîne délimitée par des positions en octets :

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "naïve café"

	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[0], string(s[0]))
	fmt.Println(s[:5]) // first 5 bytes
	fmt.Println(s[6:]) // from byte 6 to the end

	r := []rune(s)
	fmt.Println(string(r[:5])) // first 5 characters
}

ï et é occupent deux octets chacun, donc la chaîne fait 12 octets et 10 caractères. Découper par octets est sûr tant que les positions viennent de strings.Index ou d'une fonction similaire, qui renvoient des positions en octets situées sur des frontières de caractères. Pour prendre « les n premiers caractères », convertissez d'abord en []rune. La page runes et octets explique l'UTF-8 en profondeur.

Les chaînes sont immuables

Vous ne pouvez pas modifier un octet sur place : s[0] = 'H' est une erreur de compilation (cannot assign to s[0] (neither addressable nor a map index expression)). Chaque fonction de strings renvoie une nouvelle chaîne. Pour modifier, convertissez en []byte ou []rune, modifiez la slice, et reconvertissez :

b := []byte("hello")
b[0] = 'H'
s := string(b) // "Hello"

L'immuabilité explique aussi pourquoi les sous-chaînes coûtent peu : s[2:5] partage la mémoire de s au lieu de la copier. Le revers, c'est qu'une petite sous-chaîne d'une énorme chaîne garde toute l'énorme chaîne en vie. Utilisez strings.Clone (Go 1.20) quand vous gardez un petit morceau d'une grosse entrée.

Comparer des chaînes

== et != comparent le contenu, et <, > comparent octet par octet, ce qui correspond à l'ordre alphabétique pour l'ASCII. strings.Compare existe mais sert rarement ; slices.Sort sur une []string utilise <. Pour trier du texte non anglais selon les règles d'une langue, utilisez golang.org/x/text/collate.

Convertir d'autres types

Les nombres deviennent des chaînes avec strconv.Itoa, strconv.FormatFloat ou fmt.Sprintf, et les chaînes deviennent des nombres avec strconv.Atoi et strconv.ParseFloat. N'écrivez pas string(42) : cela produit le caractère de point de code 42, "*". La page sur la conversion de types contient le tableau complet.

query := `SELECT id, name
FROM users
WHERE active = true`