0Pricing
Go Academy · Lekcja

Podstawowe interfejsy biblioteki standardowej

fmt.Stringer, io.Reader, io.Writer

Podstawowe interfejsy biblioteki standardowej to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 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.

fmt.Stringer

fmt.Stringer ma jedną metodę: String() string. Zaimplementuj ją, aby określić sposób wyświetlania typu za pomocą fmt.Println i %v:

package main
import "fmt"

type Color int
const (Red Color = iota; Green; Blue)
func (c Color) String() string {
    return []string{"Red","Green","Blue"}[c]
}

func main() {
    fmt.Println(Red, Green, Blue) // Red Green Blue
}

Interfejs error

Wbudowany interfejs error ma jedną metodę: Error() string. Każdy typ, który ją implementuje, może być używany jako błąd:

package main
import "fmt"

type ValidationError struct{ Field, Msg string }
func (e *ValidationError) Error() string {
    return e.Field + ": " + e.Msg
}

func validate(age int) error {
    if age < 0 { return &ValidationError{"age", "must be non-negative"} }
    return nil
}

func main() {
    fmt.Println(validate(-1))
}

io.Reader

io.Reader ma jedną metodę: Read(p []byte) (n int, err error). Implementują go pliki, treści odpowiedzi HTTP, ciągi znaków i bufory:

package main
import ("fmt"; "strings")

func countBytes(r interface{ Read([]byte)(int,error) }) int {
    buf := make([]byte, 512)
    total := 0
    for {
        n, err := r.Read(buf)
        total += n
        if err != nil { break }
    }
    return total
}

func main() {
    r := strings.NewReader("hello world")
    fmt.Println(countBytes(r)) // 11
}

io.Writer

io.Writer ma jedną metodę: Write(p []byte) (n int, err error). Jest używany przez fmt.Fprintf, mechanizmy logowania, obiekty zapisujące odpowiedzi HTTP itd.:

package main
import ("bytes"; "fmt")

func main() {
    var buf bytes.Buffer
    fmt.Fprintf(&buf, "Hello, %s!", "Go")
    fmt.Println(buf.String()) // Hello, Go!
}

io.ReadWriter i io.Closer

Biblioteka standardowa łączy małe interfejsy w większe:

package main
import "io"

// io.ReadWriter = io.Reader + io.Writer
// io.ReadCloser = io.Reader + io.Closer
// io.ReadWriteCloser = all three

func process(rw io.ReadWriter) {
    buf := make([]byte, 8)
    rw.Read(buf)
    rw.Write(buf)
}

func main() { _ = process }

sort.Interface

sort.Interface wymaga metod Len() int, Less(i, j int) bool i Swap(i, j int):

package main
import ("fmt"; "sort")

type ByLength []string
func (b ByLength) Len() int           { return len(b) }
func (b ByLength) Less(i, j int) bool { return len(b[i]) < len(b[j]) }
func (b ByLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }

func main() {
    fruits := ByLength{"banana","apple","kiwi"}
    sort.Sort(fruits)
    fmt.Println([]string(fruits)) // [kiwi apple banana]
}

http.Handler

http.Handler ma jedną metodę: ServeHTTP(ResponseWriter, *Request). Cały stos HTTP w Go jest oparty na tym jednym interfejsie:

package main
import ("fmt"; "net/http")

type Hello struct{}
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
}

func main() {
    http.ListenAndServe(":8080", Hello{})
}

fmt.GoStringer

Zaimplementuj GoString() string, aby określić reprezentację typu w składni Go dla formatu %#v:

package main
import "fmt"

type Version struct{ Major, Minor int }
func (v Version) GoString() string {
    return fmt.Sprintf("Version{%d, %d}", v.Major, v.Minor)
}

func main() {
    fmt.Printf("%#v\n", Version{1, 18}) // Version{1, 18}
}

encoding.TextMarshaler

Zaimplementuj MarshalText() ([]byte, error) i UnmarshalText([]byte) error na potrzeby niestandardowego kodowania tekstu (ciągi JSON, YAML itd.):

package main
import "fmt"

type Status int
const (Active Status = iota; Inactive)
func (s Status) MarshalText() ([]byte, error) {
    if s == Active { return []byte("active"), nil }
    return []byte("inactive"), nil
}

func main() {
    s := Active
    b, _ := s.MarshalText()
    fmt.Println(string(b)) // active
}

Łączenie standardowych interfejsów

Łącz standardowe interfejsy za pomocą io.TeeReader, io.MultiWriter itd., aby tworzyć wydajne potoki bez pisania nowych typów:

package main
import ("bytes"; "fmt"; "io"; "strings")

func main() {
    r := strings.NewReader("hello")
    var buf bytes.Buffer
    tee := io.TeeReader(r, &buf)
    io.ReadAll(tee)
    fmt.Println(buf.String()) // hello
}

Szybkie sprawdzenie

Jaki interfejs musi implementować typ, aby można go było używać jako błędu w Go?

Podsumowanie

Najważniejsze interfejsy biblioteki standardowej:

  • fmt.Stringer — niestandardowa reprezentacja podczas wyświetlania
  • error — wartości błędów
  • io.Reader / io.Writer — strumieniowe operacje wejścia-wyjścia
  • sort.Interface — niestandardowe sortowanie
  • http.Handler — obsługa żądań HTTP

Polecenie ćwiczeniowe

Zaimplementuj sort.Interface dla []Person (gdzie Person ma pola Name i Age), aby sortować według wieku malejąco. Wyświetl posortowaną listę.

Często zadawane pytania

Czy lekcja „Podstawowe interfejsy biblioteki standardowej” jest bezpłatna?

Tak — pełny tekst „Podstawowe interfejsy biblioteki standardowej” 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 „Podstawowe interfejsy biblioteki standardowej”?

fmt.Stringer, io.Reader, io.Writer Ć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 2 z 4.

Ile czasu zajmuje lekcja „Podstawowe interfejsy biblioteki standardowej”?

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. Definiowanie i implementowanie interfejsów
  2. Podstawowe interfejsy biblioteki standardowej
  3. Asercje typów i przełączniki typów
  4. Kompozycja interfejsów i dobre praktyki
← Powrót do Go Academy