الواجهات في Golang: التطبيق الضمني وany وفخ nil

الواجهة مجموعة توابع

يسرد نوع الواجهة (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. هذا هو التطبيق الضمني، الميزة المميّزة لواجهات Go. ويعني أنك تستطيع تعريف واجهة في حزمتك تحقّقها أصلًا أنواع من حزم أخرى، دون المساس بشيفرتها.

واجهات صغيرة من المكتبة القياسية

تفضّل شيفرة Go الواجهات ذات التابع أو التابعين. أهمها:

لأن لـ 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: "كلما كبرت الواجهة ضعف التجريد". الواجهات الأكبر تُبنى بتركيب الصغيرة: io.ReadWriter هي Reader زائد Writer، وتُكتب بتضمين واجهة في أخرى.

any: الواجهة الفارغة

ليس لـ 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 switch. فضّل واجهة حقيقية أو الأنواع العامة عندما تكون مجموعة الأنواع معروفة. تناسب any البيانات الديناميكية فعلًا مثل JSON المفكوك ذي الشكل المجهول، والطباعة.

ما الذي تحتويه قيمة الواجهة

قيمة الواجهة زوج: نوع ديناميكي وقيمة ديناميكية. تخزّن var s Shape = Rect{3, 4} النوع Rect ونسخة من القيمة. واستدعاء s.Area() يبحث عن تابع Rect وقت التشغيل.

الواجهة تساوي nil فقط عندما يكون الجزآن فارغين. وهذه القاعدة تسبّب أكثر الأخطاء إرباكًا في Go.

فخ الواجهة nil

المؤشر nil المخزّن في واجهة يصنع واجهة ليست 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) واجهة error تحمل النوع *MyError والقيمة nil. للواجهة نوع، فلا تساوي nil، وينفَّذ فرع if err != nil عند المستدعي. واستدعاء err.Error() هناك سيسبّب panic عند الوصول إلى حقل المستقبِل nil.

الإصلاح بسيط: عرّف المتغيّر بالنوع error لا بنوع المؤشر المحدّد، أو أعد nil حرفيًا في مسار النجاح. لا تعد أبدًا نوع مؤشر خطأ محدّدًا من دالة نتيجتها error. والفخ نفسه ينطبق على أي واجهة، لا على الأخطاء وحدها.

التحقّق من أن نوعًا يطبّق واجهة

يُفحص التطبيق حيث تُسند قيمة إلى واجهة. إذا لم تفعل أي شيفرة ذلك بعد، يمرّ خطأ في توقيع تابع دون أن يلاحظه أحد. الإسناد الفارغ على مستوى الحزمة يجعل الفحص صريحًا:

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

لا يكلّف هذا شيئًا وقت التشغيل. إذا كان لـ *LogWriter التابع Write(p []byte) error بدل Write(p []byte) (int, error)، يفشل البناء:

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)

مستقبِلات المؤشر والواجهات

إذا كان للتابع مستقبِل مؤشر، فنوع المؤشر وحده يملك ذلك التابع. يحقّق *Counter الواجهة عبره؛ ولا يحقّقها Counter. يقول المترجم Counter does not implement Incrementer (method Inc has pointer receiver). خزّن &Counter{} في الواجهة. صفحة التوابع تشرح مجموعات التوابع.

اقبل الواجهات، وأعد البنى

إرشاد شائع في Go: يجب أن تأخذ الدوال معاملات من أنواع واجهات وتعيد أنواعًا محدّدة.

• قبول واجهة يتيح للمستدعين تمرير أي شيء يناسب، بما في ذلك البدائل الوهمية للاختبار. الدالة التي تقرأ بيانات يجب أن تأخذ io.Reader لا *os.File.
• إعادة نوع محدّد تتيح للمستدعين استخدام كل توابعه وحقوله، وتتجنّب فخ الواجهة nil. تعيد os.Open النوع *os.File لا io.Reader.

عادة مرتبطة: عرّف الواجهات حيث تُستخدم، لا حيث تُطبَّق. إذا احتاجت خدمتك إلى شيء يستطيع Get(id) لمستخدم، فعرّف واجهة بتابع واحد في حزمة خدمتك، ودع حزمة قاعدة البيانات تصدّر بنيتها فقط.

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))
}

مقارنة قيم الواجهات

تتساوى قيمتا واجهة عندما يتطابق نوعاهما الديناميكيان وتتساوى قيمتاهما الديناميكيتان. إذا كان النوع الديناميكي غير قابل للمقارنة (شريحة أو خريطة)، تُترجم == لكنها تسبّب panic وقت التشغيل: runtime error: comparing uncomparable type []int.

أخطاء شائعة

• إعادة مؤشر nil ذي نوع كواجهة. أعد nil حرفيًا.
• الواجهات المبكرة. اكتب النوع المحدّد أولًا. أضف واجهة عندما يحتاجها تطبيق ثانٍ أو اختبار.
• مؤشر إلى واجهة. *io.Reader لا يكون صحيحًا تقريبًا أبدًا. الواجهة تحمل مؤشرًا أصلًا عندما تخزّن مؤشرًا فيها.
• الواجهات الكبيرة. الواجهات ذات العشرة توابع صعبة التطبيق وصعبة المحاكاة. قسّمها.