0Pricing
Go Academy · Lekcja

Strumieniowe przetwarzanie dużych plików

Przetwarzaj pliki bez wczytywania ich w całości

Strumieniowe przetwarzanie dużych plików to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Problem z wczytywaniem wszystkiego

Wczytanie wielogigabajtowego pliku do pamięci za pomocą os.ReadFile może wyczerpać pamięć RAM. Zamiast tego przetwarzaj go strumieniowo: przetwarzaj kolejne fragmenty w miarę ich napływania.

Koncepcja strumieniowania

Strumieniowanie oznacza, że w danym momencie przechowujesz w pamięci tylko niewielkie okno danych. W połączeniu z buforowaniem pozwala ono przetwarzać dane wejściowe o dowolnym rozmiarze przy stałym zużyciu pamięci.

Odczyt wiersz po wierszu za pomocą Scanner

W przypadku tekstu bufio.Scanner działający na readerze przetwarza jeden wiersz naraz, niezależnie od rozmiaru pliku. Tutaj symulujemy plik za pomocą strings.Reader.

package main

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

func main() {
	src := strings.NewReader("alpha\nbeta\ngamma")
	s := bufio.NewScanner(src)
	for s.Scan() {
		fmt.Println("processed:", s.Text())
	}
}

Zliczanie bez wczytywania całości

Możesz obliczać statystyki dla ogromnego strumienia, przechowując w pamięci niemal nic.

package main

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

func main() {
	s := bufio.NewScanner(strings.NewReader("a\nbb\nccc"))
	total := 0
	for s.Scan() {
		total += len(s.Text())
	}
	fmt.Println("total chars:", total)
}

Fragmenty o stałym rozmiarze

W przypadku danych binarnych odczytuj dane do bufora o stałym rozmiarze za pomocą Read. n informuje, ile bajtów zostało wypełnionych.

package main

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

func main() {
	src := strings.NewReader("0123456789")
	buf := make([]byte, 4)
	for {
		n, err := src.Read(buf)
		if n > 0 {
			fmt.Printf("chunk: %s\n", buf[:n])
		}
		if err == io.EOF {
			break
		}
	}
}

io.Copy do strumieniowania

io.Copy(dst, src) przesyła strumieniowo wszystkie dane z readera do writera, używając niewielkiego wewnętrznego bufora — bez wczytywania całości.

package main

import (
	"io"
	"os"
	"strings"
)

func main() {
	src := strings.NewReader("streamed straight through\n")
	io.Copy(os.Stdout, src)
}

Łączenie buforów Reader i Writer

Opakuj oba końce w bufio, aby wydajnie przekształcać strumień: buforowany odczyt, przetwarzanie, buforowany zapis i opróżnienie bufora.

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	r := bufio.NewScanner(strings.NewReader("one\ntwo"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for r.Scan() {
		w.WriteString(r.Text() + "!\n")
	}
}

Gwarancja stałego zużycia pamięci

Ponieważ rozmiar bufora jest stały, zużycie pamięci pozostaje na tym samym poziomie niezależnie od tego, czy dane wejściowe mają 1 KB, czy 1 TB. To najważniejsza zaleta strumieniowania.

Unikanie typowych błędów

  • Nie wywołuj os.ReadFile dla ogromnych plików
  • Zawsze obsłuż n bajtów przed sprawdzeniem błędu
  • Pamiętaj o wywołaniu Flush() dla buforowanych writerów

Przekształcanie strumienia

Tutaj zamieniamy każdy wiersz na wielkie litery podczas jego przesyłania przez strumień, przechowując w pamięci tylko jeden wiersz naraz.

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	s := bufio.NewScanner(strings.NewReader("hi\nthere"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for s.Scan() {
		w.WriteString(strings.ToUpper(s.Text()) + "\n")
	}
}

Kiedy używać strumieniowania

Używaj strumieniowania, gdy rozmiar danych wejściowych jest duży lub nieznany albo gdy możesz przetwarzać dane przyrostowo. Wczytuj całość tylko w przypadku małych, ograniczonych danych, których potrzebujesz jednocześnie.

Szybki test

Sprawdź swoją wiedzę na temat strumieniowania.

Podsumowanie

Dowiedziałeś się, jak przetwarzać duże ilości danych bez wczytywania ich w całości.

  • Scanner do odczytu tekstu wiersz po wierszu
  • Read o stałym rozmiarze do fragmentów danych binarnych
  • io.Copy do przesyłania danych między strumieniami
  • Buforowanie obu końców, opróżnianie writerów i stałe zużycie pamięci

Często zadawane pytania

Czy lekcja „Strumieniowe przetwarzanie dużych plików” jest bezpłatna?

Tak — pełny tekst „Strumieniowe przetwarzanie dużych plików” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Strumieniowe przetwarzanie dużych plików”?

Przetwarzaj pliki bez wczytywania ich w całości Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Strumieniowe przetwarzanie dużych plików”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Buforowane obiekty odczytujące
  2. Skanery
  3. Buforowane obiekty zapisujące
  4. Strumieniowe przetwarzanie dużych plików
← Powrót do Go Academy