Go Academy · Lektion

Implementering af egne readers

Opret egne streams

Lektion 4 af 413 trin

Implementering af egne readers er en gratis Go Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Go Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Go Academy-kurset indeholder 4 lektioner i alt.

Byg dine egne datastrømme

Du kan oprette tilpassede datakilder ved at implementere grænsefladen io.Reader, som kun har én metode. Din type fungerer derefter sammen med alle io-hjælpefunktioner.

Metoden, der skal implementeres

Implementér Read(p []byte) (n int, err error) på din type. Udfyld p, returnér antallet, og returnér io.EOF, når du er færdig.

En konstant læser

Her er en læser, der uendeligt udsender den samme byte, begrænset med LimitReader.

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

Signalering af EOF

Returnér io.EOF, når din kilde er tømt. Du kan returnere den alene eller sammen med de sidste bytes.

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

Læsning fra en slice

En tilpasset læser kan holde styr på en position i de underliggende data og returnere en del ved hvert kald.

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

En transformerende læser

Ompak en anden læser, og transformér bytes undervejs — her ændres hver byte til stort bogstav, mens den strømmer igennem.

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

Respektér bufferlængden

Skriv aldrig mere end len(p) bytes. Brug copy(p, src), som er begrænset af den mindste slice, og returnér det antal, der blev kopieret.

Værdi- kontra pointermodtagere

Hvis din læser holder styr på en position eller tilstand, skal du bruge en pointermodtager, så ændringerne bevares mellem kald. Tilstandsløse læsere kan bruge en værdimodtager.

Sammensætning med io-hjælpefunktioner

Fordi din type opfylder io.Reader, kan den uden ekstra arbejde bruges i io.Copy, bufio.NewReader, io.LimitReader og flere.

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

Almindelige faldgruber

At glemme at returnere io.EOF (uendelig læsning)
At skrive forbi len(p)
At bruge en værdimodtager til læsere med tilstand

Hvorfor tilpassede læsere

De lader dig tilpasse enhver kilde — generatorer, afkodere, hastighedsbegrænsere og krypterede strømme — til det universelle Go-I/O-økosystem.

Hurtig kontrol

Test din viden om tilpassede læsere.

Besvar den i den interaktive lektion

Opsummering

Du har lært at bygge dine egne datastrømme.

Implementér Read(p []byte) (int, error)
Brug copy, og respekter len(p)
Returnér io.EOF, når du er færdig
Brug en pointermodtager til læsere med tilstand
Sammensæt dem med alle io-hjælpefunktioner uden ekstra arbejde

Gratis at komme i gang

Lær Go med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Implementering af egne readers” gratis?

Ja — alle 3 lektioner i læringssporet Go Academy, inklusive “Implementering af egne readers”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Go Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Implementering af egne readers”?

Opret egne streams Du øver dig i Go Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Go Academy?

Der kræves ingen tidligere erfaring. Go Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Implementering af egne readers”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Go Academy-lektion?

Ja. Alle Go Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Go Academy