Go Academy · Lektion

Die Packages fmt und strings

Ausgaben formatieren und Strings bearbeiten

Die Packages fmt und strings ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Überblick über das fmt-Package

Das fmt-Package implementiert formatierte Ein- und Ausgabe. Wichtige Funktionen:

fmt.Print, fmt.Println, fmt.Printf — schreiben auf stdout
fmt.Sprint, fmt.Sprintf, fmt.Sprintln — geben Strings zurück
fmt.Fprint, fmt.Fprintf — schreiben in jeden io.Writer
fmt.Scan, fmt.Scanf — lesen von stdin

fmt-Formatierungsverben

Häufig verwendete Formatierungsverben für fmt.Printf:

package main
import "fmt"

func main() {
    name := "Gopher"
    age := 15
    score := 98.6

    fmt.Printf("%s is %d years old\n", name, age)
    fmt.Printf("Score: %.1f%%\n", score)
    fmt.Printf("Type: %T, Value: %v\n", age, age)
    fmt.Printf("Hex: %x, Binary: %b\n", 255, 255)
    fmt.Printf("Padded: %10s|%-10s\n", name, name)
}

fmt.Sprintf zum Erstellen von Strings

fmt.Sprintf gibt einen formatierten String zurück, ohne ihn auszugeben — nützlich zum Erstellen von Strings:

package main
import "fmt"

func formatUser(name string, age int) string {
    return fmt.Sprintf("User{name: %q, age: %d}", name, age)
}

func main() {
    fmt.Println(formatUser("Alice", 30))
    // User{name: "Alice", age: 30}

    // %q adds quotes; %+v prints struct field names
    type Point struct{X, Y int}
    p := Point{1, 2}
    fmt.Printf("%+v\n", p) // {X:1 Y:2}
}

fmt.Errorf zum Formatieren von Fehlern

fmt.Errorf erstellt formatierte Fehlerwerte:

package main
import "fmt"

func getUser(id int) error {
    return fmt.Errorf("getUser(%d): user not found", id)
}

func main() {
    err := getUser(42)
    fmt.Println(err) // getUser(42): user not found

    // Wrap errors with %w for unwrapping:
    base := fmt.Errorf("base error")
    wrapped := fmt.Errorf("context: %w", base)
    fmt.Println(wrapped)
}

strings-Package: Häufig verwendete Funktionen

Das strings-Package stellt Funktionen zur Bearbeitung von Strings bereit:

package main
import ("fmt"; "strings")

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

    fmt.Println(strings.TrimSpace(s))           // "Hello, Go World!"
    fmt.Println(strings.ToUpper(s))             // "  HELLO, GO WORLD!  "
    fmt.Println(strings.ToLower(s))             // "  hello, go world!  "
    fmt.Println(strings.Contains(s, "Go"))      // true
    fmt.Println(strings.HasPrefix(s, "  Hel")) // true
    fmt.Println(strings.Count(s, "l"))          // 3
}

strings.Split und strings.Join

strings.Split teilt einen String auf, strings.Join verbindet einen Slice:

package main
import ("fmt"; "strings")

func main() {
    csv := "alice,bob,carol,dave"
    names := strings.Split(csv, ",")     // ["alice" "bob" "carol" "dave"]
    fmt.Println(names)

    upper := make([]string, len(names))
    for i, n := range names {
        upper[i] = strings.ToUpper(n)
    }
    result := strings.Join(upper, " | ")
    fmt.Println(result) // ALICE | BOB | CAROL | DAVE
}

strings.Replace und strings.ReplaceAll

Vorkommen eines Teilstrings ersetzen:

package main
import ("fmt"; "strings")

func main() {
    s := "foo bar foo baz foo"

    // Replace first 2 occurrences
    fmt.Println(strings.Replace(s, "foo", "XXX", 2))
    // XXX bar XXX baz foo

    // Replace all
    fmt.Println(strings.ReplaceAll(s, "foo", "GO"))
    // GO bar GO baz GO
}

strings.Builder für effiziente Verkettung

Verwenden Sie strings.Builder, um Strings effizient zu erstellen — dadurch wird vermieden, für jede Verkettung einen neuen String zu allokieren:

package main
import ("fmt"; "strings")

func join(parts []string, sep string) string {
    var sb strings.Builder
    for i, p := range parts {
        if i > 0 { sb.WriteString(sep) }
        sb.WriteString(p)
    }
    return sb.String()
}

func main() {
    fmt.Println(join([]string{"a", "b", "c"}, "-")) // a-b-c
}

strings.NewReader und strings.Reader

strings.NewReader erstellt aus einem String einen io.Reader — nützlich zum Testen von Funktionen, die Reader akzeptieren:

package main
import ("fmt"; "io"; "strings")

func readAll(r io.Reader) string {
    data, _ := io.ReadAll(r)
    return string(data)
}

func main() {
    r := strings.NewReader("Hello from a string reader")
    fmt.Println(readAll(r))

    // Also: strings.NewReplacer for multiple replacements
    rep := strings.NewReplacer("<", "&lt;", ">", "&gt;")
    fmt.Println(rep.Replace("<b>bold</b>"))
}

strings.Fields und strings.Map

Weitere nützliche Funktionen des strings-Packages:

package main
import ("fmt"; "strings")

func main() {
    // Fields splits on any whitespace (like awk)
    words := strings.Fields("  one  two   three  ")
    fmt.Println(words) // [one two three]

    // Map applies a function to each rune
    rot13 := func(r rune) rune {
        if r >= 'a' && r <= 'z' { return 'a' + (r-'a'+13)%26 }
        if r >= 'A' && r <= 'Z' { return 'A' + (r-'A'+13)%26 }
        return r
    }
    fmt.Println(strings.Map(rot13, "Hello, World!"))
}

Wissenscheck

Welche Funktion sollten Sie verwenden, um viele Strings in Go effizient zu verketten?

Zusammenfassung: fmt und strings

Zusammenfassung:

fmt.Printf/Sprintf für formatierte Ausgabe bzw. Strings mit Formatierungsverben (%s %d %f %v %T %q)
fmt.Errorf für formatierte Fehler, %w zum Wrappen
strings.Split/Join, Contains, Replace, TrimSpace, ToUpper/Lower
strings.Builder für effiziente Verkettung
strings.NewReader, um einen String als io.Reader zu verwenden

Häufig gestellte Fragen

Ist die Lektion „Die Packages fmt und strings“ kostenlos?

Ja — der vollständige Text von „Die Packages fmt und strings“ 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 „Die Packages fmt und strings“?

Ausgaben formatieren und Strings bearbeiten 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 1 von 4.

Wie lange dauert die Lektion „Die Packages fmt und strings“?

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