חקור את הרעיון של השתקפות בשפת התכנות Go, תוך התעמקות ביכולות החזקות שלה לניתוח קוד דינמי ומניפולציה.

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

השתקפות היא המנגנון שגו משתמש בה כדי להשיג את היכולת הזו. מהי אם כן השתקפות, וכיצד תוכל ליישם השתקפות ביישומי Go שלך?

מהי השתקפות?

רפלקציה היא היכולת של תוכנית לבחון את המשתנים והמבנה שלה ולתפעל אותם בזמן הריצה.

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

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

הבנת חבילת reflect in Go

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

ה משקף חבילה היא אחת מהחבילות הרבות הללו. זה מורכב מכל השיטות שאתה צריך כדי ליישם רפלקציה ביישומי Go.

instagram viewer

כדי להתחיל עם משקף חבילה, אתה יכול פשוט לייבא אותה כך:

import"reflect"

החבילה מגדירה שני סוגים עיקריים שמניחים את הבסיס לשיקוף ב-Go: משקף. סוּג ו משקף. ערך.

א סוּג הוא פשוט סוג Go. משקף. סוּג הוא ממשק המורכב משיטות שונות לזיהוי סוגים שונים ובחינת מרכיביהם.

הפונקציה לבדיקת סוג אובייקט כלשהו ב-Go, משקף. סוג של, מקבל כל ערך (an מִמְשָׁק{}) כטיעון היחיד שלו ומחזיר א משקף. סוּג ערך המייצג את הסוג הדינמי של האובייקט.

הקוד שלהלן מדגים את השימוש ב משקף. סוג של:

x := "3.142"
y := 3.142
z := 3
typeOfX := reflect.TypeOf(x)
typeOfY := reflect.TypeOf(y)
typeOfZ := reflect.TypeOf(z)
fmt.Println(typeOfX, typeOfY, typeOfZ) // string float64 int

הסוג השני ב משקף חֲבִילָה, משקף. ערך יכול להחזיק ערך מכל סוג שהוא. ה משקף. ערך של הפונקציה מקבלת כל מִמְשָׁק{} ומחזירה את הערך הדינמי של הממשק.

הנה דוגמה שמראה כיצד להשתמש משקף. ערך של כדי לבדוק את הערכים למעלה:

valueOfX := reflect.ValueOf(x)
valueOfY := reflect.ValueOf(y)
valueOfZ := reflect.ValueOf(z)
fmt.Println(valueOfX, valueOfY, valueOfZ) // 3.142 3.142 3

כדי לבדוק את הסוגים והסוגים של הערכים, אתה יכול להשתמש ב- סוג ו סוּג שיטה כזו:

typeOfX2 := valueOfX.Type()
kindOfX := valueOfX.Kind()
fmt.Println(typeOfX2, kindOfX) // string string

למרות שהתוצאה של שתי קריאות הפונקציות זהה, הן שונות. typeOfX2 זה בעצם אותו דבר כמו typeOfX כי שניהם דינמיים משקף. סוּג ערכים, אבל kindOfX הוא קבוע שערכו הוא הסוג הספציפי של איקס, חוּט.

זו הסיבה שיש מספר סופי של סוגים כגון int, חוּט, לָצוּף, מַעֲרָך, וכו', אבל מספר אינסופי של סוגים שכן יכולים להיות מספר סוגים המוגדרים על ידי המשתמש.

א מִמְשָׁק{} וכן א משקף. ערך עובד כמעט באותו אופן, הם יכולים להחזיק ערכים מכל סוג.

ההבדל ביניהם טמון איך ריק מִמְשָׁק{} לעולם אינו חושף את הפעולות והשיטות המקוריות של הערך שיש לה. אז ברוב הפעמים אתה צריך לדעת את הסוג הדינמי של הערך ולהשתמש בקביעת סוג כדי לגשת אליו (כלומר. i.(מחרוזת), x.(int)וכו') לפני שתוכל לבצע איתו פעולות.

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

יישום רפלקציה בתוכניות Go

השתקפות היא רחבה מאוד ויכולה למצוא שימוש בתוכנית בכל נקודת זמן. להלן כמה דוגמאות מעשיות המדגימות את השימוש בהשתקפות בתוכניות:

  • בדוק שוויון עמוק: ה משקף החבילה מספקת את DeepEqual פונקציה לבדיקת ערכי שני אובייקטים לעומק לשוויון. לדוגמה, שני מבנים שווים במידה רבה אם לכל השדות התואמים שלהם יש אותם סוגים וערכים. הנה קוד לדוגמה:
     // deep equality of two arrays
     arr1 := [...]int{1, 2, 3}
     arr2 := [...]int{1, 2, 3}
     fmt.Println(reflect.DeepEqual(arr1, arr2)) // true
  • העתק פרוסות ומערכים: אתה יכול גם להשתמש ב-Go Reflection API כדי להעתיק את התוכן של פרוסה או מערך אחד לאחר. כך:
     slice1 := []int{1, 2, 3}
     slice2 := []int{4, 5, 6}
     reflect.Copy(reflect.ValueOf(slice1), reflect.ValueOf(slice2))
     fmt.Println(slice1) // [4 5 6]
  • הגדרת פונקציות כלליות: שפות כמו TypeScript לספק סוג גנרי, כל, שבו אתה יכול להשתמש כדי להחזיק משתנים מכל סוג. בעוד ש-Go לא מגיע עם סוג גנרי מובנה, אתה יכול להשתמש בהשתקפות כדי להגדיר פונקציות גנריות. לדוגמה:
     // print the type of any value
     funcprintType(x reflect.Value) {
     fmt.Println("Value type:", x.Type())
     }
  • גישה לתגי struct: תגים משמשים להוספת מטא נתונים לשדות מבנה Go, וספריות רבות משתמשות בהם כדי לקבוע ולתפעל את ההתנהגות של כל שדה. אתה יכול לגשת לתגי struct רק עם השתקפות. הקוד לדוגמה הבא מדגים זאת:
     type User struct {
     Name string`json:"name" required:"true"`
     }
     user := User{"John"}
     field, ok := reflect.TypeOf(user).Elem().FieldByName("Name")
    

     if !ok {
     fmt.Println("Field not found")
     }
     // print all tags, and value of "required"
     fmt.Println(field.Tag, field.Tag.Get("required"))
     // json:"name" required:"true" true
  • משקף ממשקים: אפשר גם לבדוק אם ערך מיישם ממשק. זה יכול להיות שימושי כאשר אתה צריך לבצע כמה שכבה נוספת של אימותים המבוססים על הדרישות והיעדים של היישום שלך. הקוד שלהלן מדגים כיצד השתקפות עוזרת לך לבדוק ממשקים ולקבוע את המאפיינים שלהם:
     var i interface{} = 3.142
     typeOfI := reflect.TypeOf(i)
     stringerInterfaceType := reflect.TypeOf(new(fmt.Stringer))
     // check if i implements the stringer interface
     impl := typeOfI.Implements(stringerInterfaceType.Elem())
     fmt.Println(impl) // false

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

מתי להשתמש בהשתקפות ובשיטות מומלצות

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

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

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

השתמש בהשתקפות בעת הצורך

Reflection זמין בשפות רבות כולל C# ו-JavaScript, ו-Go מיטיב ליישם את ה-API בצורה מצוינת. יתרון מרכזי של השתקפות ב-Go הוא שאתה יכול לפתור בעיות עם פחות קוד כאשר אתה רותם את היכולת של הספרייה.

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