Go Academy · Lektion

Implementera egna läsare

Bygg dina egna strömmar

Lektion 4 av 413 steg

Implementera egna läsare är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Go Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Go Academy innehåller totalt 4 lektioner.

Bygg egna dataströmmar

Ni kan skapa egna datakällor genom att implementera gränssnittet io.Reader, som bara har en metod. Er typ fungerar då med alla io-hjälpfunktioner.

Metoden som ska implementeras

Implementera Read(p []byte) (n int, err error) på er typ. Fyll p, returnera antalet byte och returnera io.EOF när läsningen är klar.

En konstant läsare

Här ser ni en läsare som oändligt skickar ut samma byte och begränsas 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))
}

Signalera EOF

Returnera io.EOF när källan är uttömd. Ni kan returnera det ensamt eller tillsammans med de sista byten.

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äsa från en slice

En egen läsare kan hålla reda på en position i underliggande data och returnera en del vid varje anrop.

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 transformerande läsare

Kapsla in en annan läsare och omvandla byte i farten – här görs varje byte till versal medan den strömmar.

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

Respektera buffertens längd

Skriv aldrig fler än len(p) byte. Använd copy(p, src), som begränsas av den mindre slicen, och returnera antalet byte som kopierades.

Value kontra pointer receivers

Om läsaren håller reda på en position eller ett tillstånd ska ni använda en pointer receiver, så att ändringarna finns kvar mellan anropen. Tillståndslösa läsare kan använda en value receiver.

Kombinera med io-hjälpfunktioner

Eftersom er typ uppfyller io.Reader kan den direkt användas med io.Copy, bufio.NewReader, io.LimitReader med flera.

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

Vanliga fallgropar

Glömma att returnera io.EOF (oändlig läsning)
Skriva förbi len(p)
Använda en value receiver för tillståndsbevarande läsare

Varför egna läsare

De gör det möjligt att anpassa vilken källa som helst – generatorer, avkodare, hastighetsbegränsare och krypterade dataströmmar – till Go:s universella I/O-ekosystem.

Snabbtest

Testa era kunskaper om egna läsare.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att bygga egna dataströmmar.

Implementera Read(p []byte) (int, error)
Använd copy och respektera len(p)
Returnera io.EOF när läsningen är klar
Använd en pointer receiver för tillståndsbevarande läsare
Kombinera fritt med alla io-hjälpfunktioner

Gratis att börja

Lär dig Go med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Implementera egna läsare” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Implementera egna läsare”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implementera egna läsare”?

Bygg dina egna strömmar Ni övar på Go Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Go Academy?

Du behöver inga förkunskaper. Utbildningen i Go Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Implementera egna läsare”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Go Academy-lektionen?

Ja. Varje Go Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Go Academy