Go Academy · Lektion

Buffrade läsare

Läs effektivt med bufio

Lektion 1 av 413 steg

Buffrade läsare är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 1 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.

Varför buffrade läsningar

Att läsa en byte i taget från en fil eller ett nätverk utlöser ett systemanrop varje gång. Det är långsamt.

Paketet bufio omsluter en läsare och läser in stora block i en buffert i minnet, så att små läsningar kan hämtas från bufferten.

Färre systemanrop
Mycket snabbare vid många små läsningar

Skapa en bufio.Reader

Omslut valfri io.Reader med bufio.NewReader. Här omsluter vi en strings.Reader.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("Hello, Go!"))
	fmt.Printf("buffered reader ready: %T\n", r)
}

Läsa byte

ReadByte returnerar nästa enskilda byte. Den hämtas från bufferten, inte genom ett nytt systemanrop.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("Go"))
	b1, _ := r.ReadByte()
	b2, _ := r.ReadByte()
	fmt.Printf("%c%c\n", b1, b2)
}

ReadString till en avgränsare

ReadString(delim) läser fram till den första förekomsten av avgränsarbyten och returnerar allt inklusive avgränsaren.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("first,second,third"))
	part, _ := r.ReadString(',')
	fmt.Printf("%q\n", part)
}

Förhandsgranska data

Peek(n) returnerar de nästa n byten utan att förbruka dem. Det är praktiskt när ni vill avgöra hur data ska tolkas innan ni bestämmer er.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("HTTP/1.1"))
	head, _ := r.Peek(4)
	fmt.Printf("starts with: %s\n", head)
}

Buffertstorlek

bufio.NewReaderSize(r, size) anger buffertens kapacitet. En större buffert innebär färre underliggande läsningar, men kräver mer minne.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReaderSize(strings.NewReader("data"), 4096)
	fmt.Println("buffer size:", r.Size())
}

ReadLine jämfört med ReadString

ReadString('\n') behåller radbrytningen, men många parsers föredrar att ta bort den. Scanner (i nästa lektion) hanterar detta automatiskt.

Använd ReadString när ni behöver full kontroll över avgränsare.

Hantera io.EOF

När den underliggande strömmen är slut returnerar läsmetoderna io.EOF. Kontrollera alltid detta för att veta när ni ska sluta läsa.

package main

import (
	"bufio"
	"fmt"
	"io"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("ab"))
	for {
		c, err := r.ReadByte()
		if err == io.EOF {
			break
		}
		fmt.Printf("%c", c)
	}
	fmt.Println()
}

ReadRune för Unicode

ReadRune avkodar en hel UTF-8-runa, som kan omfatta flera byte. Använd den för text med tecken som inte är ASCII.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("héllo"))
	for {
		ru, _, err := r.ReadRune()
		if err != nil {
			break
		}
		fmt.Printf("%c ", ru)
	}
	fmt.Println()
}

Läsa tills allt är klart

Ett vanligt mönster är att loopa med ReadString tills EOF för att behandla en ström rad för rad och samtidigt behålla fin kontroll.

package main

import (
	"bufio"
	"fmt"
	"io"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("a\nb\nc\n"))
	for {
		line, err := r.ReadString('\n')
		fmt.Print("got: " + line)
		if err == io.EOF {
			break
		}
	}
}

När ska ni använda bufio.Reader

För att omsluta långsamma källor (filer, sockets)
Vid många små läsningar
När ni behöver förhandsgranska eller läsa efter avgränsare/runa

För enkel radvis skanning bör ni föredra bufio.Scanner (i nästa lektion).

Snabb kontroll

Testa er förståelse av buffrade läsare.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er hur bufio.Reader minskar antalet systemanrop genom buffring.

NewReader / NewReaderSize omsluter en io.Reader
ReadByte, ReadRune och ReadString hämtar data från bufferten
Peek tittar framåt utan att förbruka data
Sluta läsa vid io.EOF

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 ”Buffrade läsare” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Buffrade 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 ”Buffrade läsare”?

Läs effektivt med bufio 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 1 av 4.

Hur lång tid tar lektionen ”Buffrade 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