Go Academy · Lektion

Eigene Reader implementieren

Eigene Streams erstellen

Eigene Reader implementieren ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Eigene Datenströme erstellen

Sie können eigene Datenquellen erstellen, indem Sie die aus einer Methode bestehende Schnittstelle io.Reader implementieren. Ihr Typ funktioniert dann mit allen io-Hilfsfunktionen.

Die zu implementierende Methode

Implementieren Sie Read(p []byte) (n int, err error) für Ihren Typ. Füllen Sie p, geben Sie die Anzahl zurück und liefern Sie io.EOF, sobald keine Daten mehr vorhanden sind.

Ein Reader mit konstantem Inhalt

Hier sehen Sie einen Reader, der endlos dasselbe Byte ausgibt und mit LimitReader begrenzt wird.

package main

import (
	"fmt"
	"io"
)

type constReader struct{ ch byte }

func (c constReader) Read(p []byte) (int, error) {
	for i := range p {
		p[i] = c.ch
	}
	return len(p), nil
}

func main() {
	r := io.LimitReader(constReader{ch: 'A'}, 5)
	data, _ := io.ReadAll(r)
	fmt.Println(string(data))
}

EOF signalisieren

Geben Sie io.EOF zurück, sobald Ihre Quelle erschöpft ist. Sie können den Wert allein oder zusammen mit den letzten Bytes zurückgeben.

package main

import (
	"fmt"
	"io"
)

type oneShot struct{ done bool }

func (o *oneShot) Read(p []byte) (int, error) {
	if o.done {
		return 0, io.EOF
	}
	o.done = true
	n := copy(p, []byte("once"))
	return n, nil
}

func main() {
	data, _ := io.ReadAll(&oneShot{})
	fmt.Println(string(data))
}

Aus einem Slice lesen

Ein eigener Reader kann eine Position in den zugrunde liegenden Daten verfolgen und bei jedem Aufruf einen Teil davon zurückgeben.

package main

import (
	"fmt"
	"io"
)

type sliceReader struct {
	data []byte
	pos  int
}

func (s *sliceReader) Read(p []byte) (int, error) {
	if s.pos >= len(s.data) {
		return 0, io.EOF
	}
	n := copy(p, s.data[s.pos:])
	s.pos += n
	return n, nil
}

func main() {
	r := &sliceReader{data: []byte("custom")}
	out, _ := io.ReadAll(r)
	fmt.Println(string(out))
}

Ein transformierender Reader

Verpacken Sie einen anderen Reader und transformieren Sie die Bytes im laufenden Betrieb – hier wird jedes Byte während des Lesens in Großbuchstaben umgewandelt.

package main

import (
	"bytes"
	"fmt"
	"io"
)

type upper struct{ r io.Reader }

func (u upper) Read(p []byte) (int, error) {
	n, err := u.r.Read(p)
	for i := 0; i < n; i++ {
		if p[i] >= 'a' && p[i] <= 'z' {
			p[i] -= 32
		}
	}
	return n, err
}

func main() {
	out, _ := io.ReadAll(upper{r: bytes.NewReader([]byte("hello"))})
	fmt.Println(string(out))
}

Die Pufferlänge beachten

Schreiben Sie niemals mehr als len(p) Bytes. Verwenden Sie copy(p, src), das durch das kleinere Slice begrenzt wird, und geben Sie die Anzahl der kopierten Bytes zurück.

Value- und Pointer-Receiver

Wenn Ihr Reader eine Position oder einen Zustand verfolgt, verwenden Sie einen Pointer-Receiver, damit Änderungen über mehrere Aufrufe hinweg erhalten bleiben. Zustandslose Reader können einen Value-Receiver verwenden.

Mit io-Hilfsfunktionen kombinieren

Da Ihr Typ io.Reader erfüllt, können Sie ihn ohne zusätzlichen Aufwand in io.Copy, bufio.NewReader, io.LimitReader und weitere Funktionen einsetzen.

package main

import (
	"io"
	"os"
)

type dots struct{ left int }

func (d *dots) Read(p []byte) (int, error) {
	if d.left == 0 {
		return 0, io.EOF
	}
	p[0] = '.'
	d.left--
	return 1, nil
}

func main() {
	io.Copy(os.Stdout, &dots{left: 4})
	os.Stdout.WriteString("\n")
}

Häufige Fehler

Vergessen, io.EOF zurückzugeben (unbegrenztes Lesen)
Über len(p) hinaus schreiben
Einen Value-Receiver für zustandsbehaftete Reader verwenden

Warum eigene Reader

Damit können Sie jede Quelle – Generatoren, Decoder, Ratenbegrenzer oder verschlüsselte Datenströme – in das universelle Go-I/O-Ökosystem integrieren.

Kurztest

Testen Sie Ihr Wissen über eigene Reader.

Zusammenfassung

Sie haben gelernt, eigene Datenströme zu erstellen.

Read(p []byte) (int, error) implementieren
copy verwenden und len(p) beachten
Bei abgeschlossenen Daten io.EOF zurückgeben
Pointer-Receiver für zustandsbehaftete Reader verwenden
Ohne zusätzlichen Aufwand mit allen io-Hilfsfunktionen kombinieren

Häufig gestellte Fragen

Ist die Lektion „Eigene Reader implementieren“ kostenlos?

Ja — der vollständige Text von „Eigene Reader implementieren“ 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 „Eigene Reader implementieren“?

Eigene Streams 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 4 von 4.

Wie lange dauert die Lektion „Eigene Reader implementieren“?

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