0Pricing
Go Academy · Pelajaran

Interface Pustaka Standar Inti

fmt.Stringer, io.Reader, io.Writer

Interface Pustaka Standar Inti adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.

fmt.Stringer

fmt.Stringer memiliki satu metode: String() string. Implementasikan metode tersebut untuk mengontrol tampilan tipe Anda dengan fmt.Println dan %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
}

Antarmuka error

Antarmuka bawaan error memiliki satu metode: Error() string. Tipe apa pun yang mengimplementasikannya dapat digunakan sebagai kesalahan:

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 memiliki satu metode: Read(p []byte) (n int, err error). Berkas, isi HTTP, string, dan buffer semuanya mengimplementasikannya:

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 memiliki satu metode: Write(p []byte) (n int, err error). Digunakan oleh fmt.Fprintf, pencatatan, penulis respons HTTP, dan sebagainya:

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 dan io.Closer

Pustaka standar menggabungkan antarmuka kecil menjadi antarmuka yang lebih besar:

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 memerlukan Len() int, Less(i, j int) bool, dan 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 memiliki satu metode: ServeHTTP(ResponseWriter, *Request). Semua bagian tumpukan HTTP Go dibangun di atas satu antarmuka ini:

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

Implementasikan GoString() string untuk mengontrol representasi tipe Anda dalam sintaks Go melalui %#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

Implementasikan MarshalText() ([]byte, error) dan UnmarshalText([]byte) error untuk pengodean teks khusus (string JSON, YAML, dan sebagainya):

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
}

Menggabungkan Antarmuka Standar

Gabungkan antarmuka standar dengan io.TeeReader, io.MultiWriter, dan sebagainya untuk membangun alur pemrosesan yang kuat tanpa menulis tipe baru:

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
}

Pemeriksaan Singkat

Antarmuka apa yang harus diimplementasikan suatu tipe agar dapat digunakan sebagai kesalahan di Go?

Rangkuman

Antarmuka pustaka standar utama:

  • fmt.Stringer — representasi cetak khusus
  • error — nilai kesalahan
  • io.Reader / io.Writer — I/O aliran
  • sort.Interface — pengurutan khusus
  • http.Handler — penanganan permintaan HTTP

Tugas Latihan

Implementasikan sort.Interface pada []Person (dengan Person yang memiliki bidang Name dan Age) untuk mengurutkan berdasarkan usia secara menurun. Cetak daftar yang telah diurutkan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Interface Pustaka Standar Inti” gratis?

Ya — teks lengkap “Interface Pustaka Standar Inti” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Interface Pustaka Standar Inti”?

fmt.Stringer, io.Reader, io.Writer Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Go Academy?

Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Interface Pustaka Standar Inti” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mendefinisikan dan Mengimplementasikan Interface
  2. Interface Pustaka Standar Inti
  3. Asersi Tipe dan Switch Tipe
  4. Komposisi Interface dan Praktik Terbaik
← Kembali ke Go Academy