Interface ב-Golang: מימוש מרומז, any ומלכודת ה-nil

interface הוא קבוצה של מתודות

טיפוס interface מפרט חתימות של מתודות. כל טיפוס שיש לו את המתודות האלה מממש את ה-interface, בלי שום הצהרה שאומרת את זה.

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
	Perimeter() float64
}

type Rect struct{ W, H float64 }

func (r Rect) Area() float64      { return r.W * r.H }
func (r Rect) Perimeter() float64 { return 2 * (r.W + r.H) }

type Circle struct{ R float64 }

func (c Circle) Area() float64      { return math.Pi * c.R * c.R }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.R }

func describe(s Shape) {
	fmt.Printf("%T area=%.2f perimeter=%.2f\n", s, s.Area(), s.Perimeter())
}

func main() {
	shapes := []Shape{Rect{3, 4}, Circle{1}}
	for _, s := range shapes {
		describe(s)
	}
}

לא Rect ולא Circle מזכירים את Shape. זה מימוש מרומז, התכונה המגדירה של interfaces ב-Go. המשמעות היא שאפשר להגדיר בחבילה שלכם interface שטיפוסים מחבילות אחרות כבר מממשים, בלי לגעת בקוד שלהם.

interfaces קטנים מהספרייה הסטנדרטית

קוד Go מעדיף interfaces עם מתודה אחת או שתיים. החשובים ביותר:

מכיוון של-io.Reader יש מתודה אחת, עשרות טיפוסים מממשים אותו, וכל פונקציה שמקבלת io.Reader עובדת עם כולם:

package main

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

func countBytes(r io.Reader) (int64, error) {
	return io.Copy(io.Discard, r)
}

type Temp float64

func (t Temp) String() string { return fmt.Sprintf("%.1f°C", float64(t)) }

func main() {
	n1, _ := countBytes(strings.NewReader("hello"))
	n2, _ := countBytes(bytes.NewBufferString("hello, gopher"))
	fmt.Println(n1, n2)

	var sb strings.Builder // an io.Writer
	fmt.Fprintf(&sb, "%d + %d = %d", 2, 2, 4)
	fmt.Println(sb.String())

	fmt.Println(Temp(21.5)) // fmt calls String()
}

הפתגם של Go אומר "ככל שה-interface גדול יותר, ההפשטה חלשה יותר". interfaces גדולים יותר נבנים משילוב של קטנים: io.ReadWriter הוא Reader ועוד Writer, שנכתב על ידי הטמעה של interface אחד בתוך אחר.

any: ה-interface הריק

ל-interface{} אין מתודות, ולכן כל טיפוס מממש אותו. Go 1.18 הוסיפה את any ככינוי; הם זהים.

package main

import "fmt"

func main() {
	var v any

	v = 42
	fmt.Printf("%v %T\n", v, v)

	v = "text"
	fmt.Printf("%v %T\n", v, v)

	v = []int{1, 2}
	fmt.Printf("%v %T\n", v, v)

	items := []any{1, "two", 3.0, nil}
	fmt.Println(len(items))

	if s, ok := v.([]int); ok {
		fmt.Println("slice of len", len(s))
	}
}

ערך any יכול להחזיק כל דבר, אבל כמעט אי אפשר לעשות איתו כלום עד שמשחזרים את הטיפוס הקונקרטי עם type assertion או type switch. העדיפו interface אמיתי או generics כשקבוצת הטיפוסים ידועה. any מתאים לנתונים דינמיים באמת, כמו JSON מפוענח במבנה לא ידוע, ולהדפסה.

מה ערך interface מכיל

ערך interface הוא זוג: טיפוס דינמי וערך דינמי. var s Shape = Rect{3, 4} שומר את הטיפוס Rect ועותק של הערך. קריאה ל-s.Area() מחפשת את המתודה של Rect בזמן ריצה.

interface הוא nil רק כששני החלקים ריקים. הכלל הזה גורם לבאג המבלבל ביותר ב-Go.

מלכודת ה-interface שהוא nil

pointer שהוא nil ונשמר בתוך interface יוצר interface שהוא לא nil.

package main

import "fmt"

type MyError struct{ Msg string }

func (e *MyError) Error() string { return e.Msg }

func validate(ok bool) error {
	var err *MyError // nil pointer
	if !ok {
		err = &MyError{"invalid input"}
	}
	return err // BUG: returns a non-nil error even when ok is true
}

func validateFixed(ok bool) error {
	if !ok {
		return &MyError{"invalid input"}
	}
	return nil
}

func main() {
	err := validate(true)
	fmt.Println(err == nil) // false
	fmt.Printf("%T %v\n", err, err == (*MyError)(nil))

	fmt.Println(validateFixed(true) == nil) // true
}

פלט:

false
*main.MyError true
true

validate(true) מחזירה interface מסוג error שמחזיק את הטיפוס *MyError ואת הערך nil. ל-interface יש טיפוס, ולכן הוא לא שווה ל-nil, והענף if err != nil של הקוד הקורא רץ. קריאה ל-err.Error() שם הייתה נכנסת ל-panic בגישה לשדה של ה-receiver שהוא nil.

התיקון פשוט: הצהירו על המשתנה כ-error, לא כטיפוס ה-pointer הקונקרטי, או החזירו nil מפורש במסלול ההצלחה. לעולם אל תחזירו טיפוס pointer קונקרטי של שגיאה מפונקציה שהתוצאה שלה היא error. אותה מלכודת חלה על כל interface, לא רק על שגיאות.

לבדוק שטיפוס מממש interface

המימוש נבדק במקום שבו ערך מושם ל-interface. אם עדיין אין קוד שעושה את זה, טעות בחתימה של מתודה עוברת בלי שישימו לב. השמה ריקה ברמת החבילה הופכת את הבדיקה למפורשת:

var _ io.Writer = (*LogWriter)(nil)
var _ fmt.Stringer = Temp(0)

זה לא עולה כלום בזמן ריצה. אם ל-*LogWriter יש Write(p []byte) error במקום Write(p []byte) (int, error), ה-build נכשל:

cannot use (*LogWriter)(nil) (value of type *LogWriter) as io.Writer value in variable declaration: *LogWriter does not implement io.Writer (wrong type for method Write)
		have Write([]byte) error
		want Write([]byte) (int, error)

pointer receivers ו-interfaces

אם למתודה יש pointer receiver, רק לטיפוס ה-pointer יש את המתודה הזאת. *Counter מממש interface דרכה; Counter לא. הקומפיילר אומר Counter does not implement Incrementer (method Inc has pointer receiver). שמרו ב-interface את &Counter{}. העמוד על מתודות מסביר את ה-method sets.

לקבל interfaces, להחזיר structs

הנחיה נפוצה ב-Go: פונקציות צריכות לקבל פרמטרים מסוג interface ולהחזיר טיפוסים קונקרטיים.

• קבלת interface מאפשרת לקוד הקורא להעביר כל דבר שמתאים, כולל fakes לבדיקות. פונקציה שקוראת נתונים צריכה לקבל io.Reader, לא *os.File.
• החזרת טיפוס קונקרטי מאפשרת לקוד הקורא להשתמש בכל המתודות והשדות שלו, ומונעת את מלכודת ה-interface שהוא nil. os.Open מחזירה *os.File, לא io.Reader.

הרגל קשור: הגדירו interfaces במקום שבו משתמשים בהם, לא במקום שבו מממשים אותם. אם ה-service שלכם צריך משהו שיכול לבצע Get(id) למשתמש, הצהירו על interface עם מתודה אחת בחבילה של ה-service, ותנו לחבילת מסד הנתונים פשוט לייצא את ה-struct שלה.

package main

import (
	"errors"
	"fmt"
)

// Declared by the consumer, with only what it needs.
type UserGetter interface {
	GetUser(id int) (string, error)
}

func greet(db UserGetter, id int) string {
	name, err := db.GetUser(id)
	if err != nil {
		return "hello, stranger"
	}
	return "hello, " + name
}

// A fake for tests or examples: no mocking library needed.
type fakeDB map[int]string

func (f fakeDB) GetUser(id int) (string, error) {
	if n, ok := f[id]; ok {
		return n, nil
	}
	return "", errors.New("not found")
}

func main() {
	db := fakeDB{1: "Ana"}
	fmt.Println(greet(db, 1))
	fmt.Println(greet(db, 2))
}

השוואת ערכי interface

שני ערכי interface שווים כשהטיפוסים הדינמיים שלהם זהים והערכים הדינמיים שלהם שווים. אם הטיפוס הדינמי לא בר השוואה (slice, map), == מתקמפל אבל נכנס ל-panic בזמן ריצה: runtime error: comparing uncomparable type []int.

טעויות נפוצות

• החזרת pointer מטיפוס מסוים שהוא nil בתור interface. החזירו nil מפורש.
• interfaces מוקדם מדי. כתבו קודם את הטיפוס הקונקרטי. הוסיפו interface כשמימוש שני או בדיקה צריכים אותו.
• pointer ל-interface. *io.Reader כמעט אף פעם לא נכון. interface כבר מחזיק pointer כששומרים בו אחד.
• interfaces גדולים. interfaces עם עשר מתודות קשים למימוש וקשים לזיוף בבדיקות. פצלו אותם.