0Pricing
Go Academy · Lektion

Zentrale Interfaces der Standardbibliothek

fmt.Stringer, io.Reader, io.Writer

Zentrale Interfaces der Standardbibliothek ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

fmt.Stringer

fmt.Stringer hat eine Methode: String() string. Implementieren Sie sie, um festzulegen, wie Ihr Typ mit fmt.Println und %v dargestellt wird:

package main
import "fmt"

type Color int
const (Red Color = iota; Green; Blue)
func (c Color) String() string {
    return []string{"Red","Green","Blue"}[c]
}

func main() {
    fmt.Println(Red, Green, Blue) // Red Green Blue
}

error-Interface

Das eingebaute error-Interface hat eine Methode: Error() string. Jeder Typ, der diese Methode implementiert, kann als Fehler verwendet werden:

package main
import "fmt"

type ValidationError struct{ Field, Msg string }
func (e *ValidationError) Error() string {
    return e.Field + ": " + e.Msg
}

func validate(age int) error {
    if age < 0 { return &ValidationError{"age", "must be non-negative"} }
    return nil
}

func main() {
    fmt.Println(validate(-1))
}

io.Reader

io.Reader hat eine Methode: Read(p []byte) (n int, err error). Dateien, HTTP-Bodies, Strings und Buffer implementieren es alle:

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

func countBytes(r interface{ Read([]byte)(int,error) }) int {
    buf := make([]byte, 512)
    total := 0
    for {
        n, err := r.Read(buf)
        total += n
        if err != nil { break }
    }
    return total
}

func main() {
    r := strings.NewReader("hello world")
    fmt.Println(countBytes(r)) // 11
}

io.Writer

io.Writer hat eine Methode: Write(p []byte) (n int, err error). Es wird von fmt.Fprintf, beim Logging, von HTTP-Response-Writer usw. verwendet:

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

func main() {
    var buf bytes.Buffer
    fmt.Fprintf(&buf, "Hello, %s!", "Go")
    fmt.Println(buf.String()) // Hello, Go!
}

io.ReadWriter und io.Closer

Die Standardbibliothek setzt kleine Interfaces zu größeren zusammen:

package main
import "io"

// io.ReadWriter = io.Reader + io.Writer
// io.ReadCloser = io.Reader + io.Closer
// io.ReadWriteCloser = all three

func process(rw io.ReadWriter) {
    buf := make([]byte, 8)
    rw.Read(buf)
    rw.Write(buf)
}

func main() { _ = process }

sort.Interface

sort.Interface erfordert Len() int, Less(i, j int) bool und Swap(i, j int):

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

type ByLength []string
func (b ByLength) Len() int           { return len(b) }
func (b ByLength) Less(i, j int) bool { return len(b[i]) < len(b[j]) }
func (b ByLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }

func main() {
    fruits := ByLength{"banana","apple","kiwi"}
    sort.Sort(fruits)
    fmt.Println([]string(fruits)) // [kiwi apple banana]
}

http.Handler

http.Handler hat eine Methode: ServeHTTP(ResponseWriter, *Request). Der gesamte HTTP-Stack von Go basiert auf diesem einzelnen Interface:

package main
import ("fmt"; "net/http")

type Hello struct{}
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
}

func main() {
    http.ListenAndServe(":8080", Hello{})
}

fmt.GoStringer

Implementieren Sie GoString() string, um die %#v-Darstellung (Go-Syntax) Ihres Typs zu steuern:

package main
import "fmt"

type Version struct{ Major, Minor int }
func (v Version) GoString() string {
    return fmt.Sprintf("Version{%d, %d}", v.Major, v.Minor)
}

func main() {
    fmt.Printf("%#v\n", Version{1, 18}) // Version{1, 18}
}

encoding.TextMarshaler

Implementieren Sie MarshalText() ([]byte, error) und UnmarshalText([]byte) error für eine benutzerdefinierte Textkodierung (JSON-Strings, YAML usw.):

package main
import "fmt"

type Status int
const (Active Status = iota; Inactive)
func (s Status) MarshalText() ([]byte, error) {
    if s == Active { return []byte("active"), nil }
    return []byte("inactive"), nil
}

func main() {
    s := Active
    b, _ := s.MarshalText()
    fmt.Println(string(b)) // active
}

Standard-Interfaces kombinieren

Kombinieren Sie Standard-Interfaces mit io.TeeReader, io.MultiWriter usw., um leistungsfähige Pipelines zu erstellen, ohne neue Typen zu schreiben:

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

func main() {
    r := strings.NewReader("hello")
    var buf bytes.Buffer
    tee := io.TeeReader(r, &buf)
    io.ReadAll(tee)
    fmt.Println(buf.String()) // hello
}

Kurztest

Welches Interface muss ein Typ implementieren, damit er in Go als Fehler verwendet werden kann?

Zusammenfassung

Wichtige Interfaces der Standardbibliothek:

  • fmt.Stringer – benutzerdefinierte Darstellung bei der Ausgabe
  • error – Fehlerwerte
  • io.Reader / io.Writer – Streaming-I/O
  • sort.Interface – benutzerdefinierte Sortierung
  • http.Handler – Verarbeitung von HTTP-Anfragen

Übungsaufgabe

Implementieren Sie sort.Interface für einen []Person-Slice (wobei Person die Felder Name und Age besitzt), um nach absteigendem Alter zu sortieren. Geben Sie die sortierte Liste aus.

Häufig gestellte Fragen

Ist die Lektion „Zentrale Interfaces der Standardbibliothek“ kostenlos?

Ja — der vollständige Text von „Zentrale Interfaces der Standardbibliothek“ 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 „Zentrale Interfaces der Standardbibliothek“?

fmt.Stringer, io.Reader, io.Writer 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 2 von 4.

Wie lange dauert die Lektion „Zentrale Interfaces der Standardbibliothek“?

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

  1. Interfaces definieren und implementieren
  2. Zentrale Interfaces der Standardbibliothek
  3. Typ-Assertions und Type-Switches
  4. Interface-Komposition und Best Practices
← Zurück zu Go Academy