Go Academy · Leçon

strings.Builder

Construire des chaînes efficacement

strings.Builder est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Le coût de la concaténation avec +

Comme les chaînes sont immuables, chaque s = s + part crée une chaîne entièrement nouvelle et recopie tous les octets.

Dans une boucle, cela devient lent et gaspille de la mémoire.

package main

import "fmt"

func main() {
    s := ""
    for i := 0; i < 3; i++ {
        s = s + "go "
    }
    fmt.Println(s)
}

Découvrez strings.Builder

strings.Builder agrandit un tampon interne et évite les copies répétées. Vous écrivez dedans, puis vous lisez le résultat une seule fois à la fin.

Déclarez-en un avec var b strings.Builder.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("Hello")
    fmt.Println(b.String())
}

WriteString dans une boucle

Le véritable gain apparaît dans les boucles. Appelez WriteString à plusieurs reprises, puis lisez le résultat une seule fois avec String().

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    for i := 0; i < 3; i++ {
        b.WriteString("go ")
    }
    fmt.Println(b.String())
}

Écrire des octets et des runes

Un Builder accepte autre chose que des chaînes complètes :

WriteByte ajoute un seul octet.
WriteRune ajoute un point de code Unicode.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("Go")
    b.WriteByte('!')
    b.WriteRune('語')
    fmt.Println(b.String())
}

Builder implémente io.Writer

Comme Builder respecte l’io.Writer interface, vous pouvez l’utiliser avec fmt.Fprintf pour formater directement dans le tampon.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    fmt.Fprintf(&b, "x=%d y=%d", 3, 4)
    fmt.Println(b.String())
}

Suivre la longueur

b.Len() vous indique combien d’octets ont été écrits jusqu’à présent, sans construire la chaîne finale.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("hello")
    fmt.Println(b.Len())
}

Préallouer avec Grow

Si vous connaissez approximativement la taille du résultat, appelez d’abord b.Grow(n). Cela réserve de la capacité et évite de redimensionner le tampon à plusieurs reprises.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.Grow(64)
    for i := 0; i < 5; i++ {
        b.WriteString("item ")
    }
    fmt.Println(b.String())
}

Ne copiez pas un Builder

Un strings.Builder ne doit pas être copié après sa première utilisation. Transmettez-le à l’aide d’un pointeur (*strings.Builder).

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("first")
    b.Reset()
    b.WriteString("second")
    fmt.Println(b.String())
}

Construire une ligne CSV

Exemple pratique : assemblez efficacement une ligne séparée par des virgules avec un Builder.

package main

import (
    "fmt"
    "strings"
)

func add(b *strings.Builder, word string) {
    b.WriteString(word)
}

func main() {
    var b strings.Builder
    add(&b, "shared ")
    add(&b, "builder")
    fmt.Println(b.String())
}

Quand utiliser un Builder

Utilisez strings.Builder lorsque vous concaténez de nombreux éléments, en particulier dans les boucles.

Pour joindre une seule fois une tranche connue, strings.Join est plus simple et tout aussi rapide.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fields := []string{"id", "name", "age"}
    var b strings.Builder
    for i, f := range fields {
        if i > 0 {
            b.WriteByte(',')
        }
        b.WriteString(f)
    }
    fmt.Println(b.String())
}

Vérification rapide

Pourquoi préférer un Builder à des + répétés dans une boucle ?

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    for i := 1; i <= 3; i++ {
        fmt.Fprintf(&b, "[%d]", i)
    }
    fmt.Println(b.String())
}

Vérification rapide

Pourquoi préférer un Builder à des + répétés dans une boucle ?

Récapitulatif : strings.Builder

Vous avez appris à construire efficacement des chaînes :

Déclarez-le avec var b strings.Builder.
Ajoutez du contenu avec WriteString, WriteByte, WriteRune ou fmt.Fprintf.
Vous pouvez utiliser Grow à l’avance, lire le résultat une seule fois avec String() et ne jamais le copier.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.Grow(16)
    b.WriteString("Go ")
    b.WriteString("builder!")
    fmt.Println(b.String())
}

Questions Fréquemment Posées

La leçon « strings.Builder » est-elle gratuite ?

Oui — le texte complet de « strings.Builder » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « strings.Builder » ?

Construire des chaînes efficacement Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « strings.Builder » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy