Go Academy · Lektion

strings.Builder

Strings effizient erstellen

strings.Builder ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Die Kosten der +-Verkettung

Da Strings unveränderlich sind, erstellt jedes s = s + part einen völlig neuen String und kopiert erneut alle Bytes.

In einer Schleife wird das langsam und verschwendet Speicher.

package main

import "fmt"

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

strings.Builder kennenlernen

strings.Builder vergrößert einen internen Puffer und vermeidet wiederholtes Kopieren. Sie schreiben in ihn hinein und lesen das Ergebnis erst am Ende einmal aus.

Erstellen Sie einen mit var b strings.Builder.

package main

import (
    "fmt"
    "strings"
)

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

WriteString in einer Schleife

Der eigentliche Vorteil zeigt sich in Schleifen. Rufen Sie wiederholt WriteString auf und lesen Sie das Ergebnis anschließend einmal mit String() aus.

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 und Runes schreiben

Ein Builder akzeptiert mehr als vollständige Strings:

WriteByte fügt ein einzelnes Byte hinzu.
WriteRune fügt einen Unicode-Codepoint hinzu.

package main

import (
    "fmt"
    "strings"
)

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

Builder implementiert io.Writer

Da Builder die Schnittstelle io.Writer erfüllt, können Sie ihn mit fmt.Fprintf verwenden, um direkt in den Puffer zu formatieren.

package main

import (
    "fmt"
    "strings"
)

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

Länge verfolgen

b.Len() teilt Ihnen mit, wie viele Bytes bisher geschrieben wurden, ohne den endgültigen String zu erstellen.

package main

import (
    "fmt"
    "strings"
)

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

Mit Grow vorallokieren

Wenn Sie ungefähr wissen, wie groß das Ergebnis sein wird, rufen Sie zuerst b.Grow(n) auf. Dadurch wird Kapazität reserviert und eine wiederholte Vergrößerung des Puffers vermieden.

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

Einen Builder zurücksetzen

b.Reset() leert den Puffer, sodass Sie denselben Builder für den nächsten String wiederverwenden können.

package main

import (
    "fmt"
    "strings"
)

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

Einen Builder nicht kopieren

Ein strings.Builder darf nach seiner ersten Verwendung nicht kopiert werden. Übergeben Sie ihn stattdessen über einen Zeiger (*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())
}

Eine CSV-Zeile erstellen

Ein praktisches Beispiel: Erstellen Sie mit einem Builder effizient eine kommagetrennte Zeile.

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

Wann Sie einen Builder verwenden sollten

Verwenden Sie strings.Builder, wenn Sie viele Teile verketten, insbesondere innerhalb von Schleifen.

Für das einmalige Verbinden eines bekannten Slices ist strings.Join einfacher und genauso schnell.

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

Schnelltest

Warum sollten Sie in einer Schleife einen Builder wiederholtem + vorziehen?

Zusammenfassung: strings.Builder

Sie haben gelernt, Strings effizient zu erstellen:

Deklarieren Sie ihn mit var b strings.Builder.
Fügen Sie Inhalte mit WriteString, WriteByte, WriteRune oder fmt.Fprintf hinzu.
Optional können Sie vorab Grow aufrufen, das Ergebnis einmal mit String() auslesen und den Builder niemals kopieren.

package main

import (
    "fmt"
    "strings"
)

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

Häufig gestellte Fragen

Ist die Lektion „strings.Builder“ kostenlos?

Ja — der vollständige Text von „strings.Builder“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „strings.Builder“?

Strings effizient erstellen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „strings.Builder“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy