כללי התאמה לממשק

חלק מהיחידה תכנות מונחה עצמים במסלול ה-GO של Coddy. שיעור 43 מתוך 107.

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

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

type Saver interface {
    Save() string
}

type Document struct{ Name string }

func (d *Document) Save() string {  // מקבל מצביע
    return "Saved: " + d.Name
}

func Process(s Saver) {
    fmt.Println(s.Save())
}

מכיוון של־Save() יש מקבל מצביע, רק *Document מקיים את Saver:

func main() {
    doc := Document{Name: "report.txt"}
    
    Process(&doc)  // עובד - המצביע מממש את הממשק
    // Process(doc)  // שגיאת קומפילציה - הערך אינו מממש את הממשק
}

עם זאת, הכיוון ההפוך גמיש יותר. אם למתודה יש מקבל ערך, גם טיפוסי הערך וגם טיפוסי המצביע עומדים בדרישות הממשק. Go מבצעת באופן אוטומטי ביטול הפניה למצביעים בעת קריאה למתודות עם מקבל ערך:

func (d Document) Info() string {  // מקבל ערך
    return d.Name
}

// גם Document וגם *Document מממשים ממשק שדורש Info()

חוסר הסימטריה הזה קיים משום ש-Go תמיד יכולה לקבל ערך ממצביע (באמצעות ביטול הפניה), אך היא לא תמיד יכולה לקבל מצביע מערך (ייתכן שאי אפשר לקבל את הכתובת של הערך). זכירת הכלל הזה מונעת שגיאות מהדר מבלבלות בעבודה עם ממשקים.

אתגר

קל

נבנה מערכת תצורה שמדגימה כיצד מקבלי מצביע ומקבלי ערך משפיעים על התאמה לממשק. תיצרו טיפוסים שבהם בחירת המקבל קובעת אם אפשר להשתמש בערכים, במצביעים או בשניהם עם ממשק.

תארגנו את הקוד שלכם בשלושה קבצים:

config.go: הגדירו ממשק Configurable שדורש שתי מתודות: GetValue() string ו-SetValue(string). לאחר מכן צרו שני טיפוסי תצורה:
- ReadOnlyConfig עם שדה Value: השתמשו במקבל ערך עבור GetValue() (מחזירה את Value) ובמקבל מצביע עבור SetValue() (מעדכנת את Value)
- Setting עם שדה Data: השתמשו במקבלי ערך עבור שתי המתודות (GetValue מחזירה את Data, ואילו SetValue רק מדפיסה "Cannot modify" בלי לשנות דבר)
processor.go: צרו פונקציה בשם ProcessConfig שמקבלת Configurable ומחרוזת של ערך חדש. עליה להדפיס את הערך הנוכחי באמצעות GetValue(), לקרוא ל-SetValue() עם הערך החדש, ואז להדפיס שוב את הערך כדי להציג שינויים כלשהם.
main.go: קראו את פרטי התצורה מהקלט והדגימו את כללי ההתאמה לממשק:
1. צרו ReadOnlyConfig והעבירו מצביע ל-ProcessConfig (נדרש משום של-SetValue יש מקבל מצביע)
2. צרו Setting והעבירו את הערך ישירות ל-ProcessConfig (עובד משום שלשתי המתודות יש מקבלי ערך)

הקלט הבא יסופק:

שורה 1: הערך ההתחלתי של ReadOnlyConfig
שורה 2: הערך החדש שיש להגדיר עבור ReadOnlyConfig
שורה 3: הערך ההתחלתי של Setting
שורה 4: הערך החדש שיש לנסות להגדיר עבור Setting

הפונקציה ProcessConfig שלכם צריכה להדפיס בפורמט הזה:

Current: [value]
Current: [value after SetValue]

לדוגמה, עבור debug, production, localhost ו-remote, הפלט שלכם צריך להיות:

Current: debug
Current: production
Current: localhost
Cannot modify
Current: localhost

שימו לב ש-ReadOnlyConfig אכן משנה את הערך שלו (משום שהעברנו מצביע), ואילו Setting נשאר ללא שינוי (ה-SetValue שלו, עם מקבל ערך, לא יכול לשנות את המקור). התובנה המרכזית היא שערכי ReadOnlyConfig לבדם לא מתאימים לממשק Configurable; רק מצביעים מתאימים לו. לעומת זאת, ערכי Setting עובדים ישירות, משום שכל המתודות שלו משתמשות במקבלי ערך.

נסו בעצמכם

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// קראו את הקלטים
	scanner.Scan()
	rocInitial := scanner.Text()
	scanner.Scan()
	rocNew := scanner.Text()
	scanner.Scan()
	settingInitial := scanner.Text()
	scanner.Scan()
	settingNew := scanner.Text()
	
	// TODO: צרו ReadOnlyConfig עם הערך של rocInitial
	// TODO: העבירו מצביע ל-ProcessConfig (נדרש כי ל-SetValue יש מקבל מסוג מצביע)
	
	// TODO: צרו Setting עם הערך של settingInitial
	// TODO: העבירו את הערך ישירות ל-ProcessConfig (עובד כי לשתי המתודות יש מקבלים מסוג ערך)
	
	// השתמשו במשתנים האלה כדי להימנע משגיאות על משתנים שלא נעשה בהם שימוש
	_ = rocInitial
	_ = rocNew
	_ = settingInitial
	_ = settingNew
}