Go Academy · Les

strings.Builder

Bouw strings efficiënt

Les 3 van 413 stappen

strings.Builder is een gratis Go Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.

De kosten van samenvoegen met +

Omdat strings onveranderlijk zijn, maakt elke s = s + part een volledig nieuwe string en worden alle bytes opnieuw gekopieerd.

In een lus wordt dit traag en verspil je geheugen.

package main

import "fmt"

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

Maak kennis met strings.Builder

strings.Builder laat een interne buffer groeien en voorkomt herhaald kopiëren. Je schrijft erin en leest het resultaat pas één keer aan het einde uit.

Declareer er een met var b strings.Builder.

package main

import (
    "fmt"
    "strings"
)

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

WriteString in een lus

Het grootste voordeel zie je in lussen. Roep WriteString herhaaldelijk aan en lees het resultaat daarna één keer uit met 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())
}

Bytes en runes schrijven

Een Builder accepteert meer dan volledige strings:

WriteByte voegt één byte toe.
WriteRune voegt één Unicode-codepunt toe.

package main

import (
    "fmt"
    "strings"
)

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

Builder implementeert io.Writer

Omdat Builder aan de io.Writer-interface voldoet, kun je deze met fmt.Fprintf gebruiken om rechtstreeks in de buffer te formatteren.

package main

import (
    "fmt"
    "strings"
)

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

De lengte bijhouden

b.Len() vertelt je hoeveel bytes er tot nu toe zijn geschreven, zonder de uiteindelijke string op te bouwen.

package main

import (
    "fmt"
    "strings"
)

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

Vooraf alloceren met Grow

Als je ongeveer weet hoe groot het resultaat wordt, roep je eerst b.Grow(n) aan. Hiermee reserveer je capaciteit en voorkom je dat de buffer herhaaldelijk groter moet worden gemaakt.

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())
}

Een Builder resetten

b.Reset() maakt de buffer leeg, zodat je dezelfde Builder opnieuw kunt gebruiken voor de volgende string.

package main

import (
    "fmt"
    "strings"
)

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

Kopieer een Builder niet

Een strings.Builder mag na het eerste gebruik niet worden gekopieerd. Geef hem in plaats daarvan door via een pointer (*strings.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())
}

Een CSV-regel opbouwen

Een praktisch voorbeeld: bouw met een Builder efficiënt een kommagescheiden regel op.

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())
}

Wanneer gebruik je een Builder?

Gebruik strings.Builder wanneer je veel onderdelen samenvoegt, vooral binnen lussen.

Voor het eenmalig samenvoegen van een bekende slice is strings.Join eenvoudiger en net zo snel.

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())
}

Korte controle

Waarom geef je in een lus de voorkeur aan een Builder boven herhaald gebruik van +?

Beantwoord dit in de interactieve les

Samenvatting: strings.Builder

Je hebt geleerd hoe je efficiënt strings opbouwt:

Declareer een Builder met var b strings.Builder.
Voeg gegevens toe via WriteString, WriteByte, WriteRune of fmt.Fprintf.
Gebruik eventueel vooraf Grow, lees het resultaat één keer uit met String() en kopieer de Builder nooit.

package main

import (
    "fmt"
    "strings"
)

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

Gratis beginnen

Leer Go met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “strings.Builder” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “strings.Builder”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.

Wat leer ik in “strings.Builder”?

Bouw strings efficiënt Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Go Academy te beginnen?

Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “strings.Builder”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Go Academy?

Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Go Academy