Reflection in Golang מאפשר לתוכנית לבחון ולשנות מבני נתונים, סוגים וערכים בזמן ריצה. הוא מספק סט של פונקציות המאפשרות לנו לבחון את הסוג והערך של כל משתנה בזמן ריצה, ליצור מופעים חדשים של סוגים ולשנות את הערך של משתנים קיימים. מאמר זה מכסה פונקציות שונות של Golang בחבילת reflect.
תוכן העניינים
- Reflect Package ב-Go
- פונקציית reflect.Copy()
- פונקציית reflect.DeepEqual()
- פונקציית reflect.Swapper()
- reflect.TypeOf() פונקציה
- reflect.ValueOf() פונקציה
- סיכום
Go היא שפה בהקלדה סטטית ולכן יש לדעת את סוג המשתנה בזמן ההידור. עם זאת, בתרחישים מסוימים, ייתכן שיהיה צורך לטפל בערכים שלא ניתן לקבוע את סוגיהם עד להפעלת התוכנית.
לדוגמה, ייתכן שנצטרך לכתוב פונקציה שיכולה לעבוד עם סוגים שונים של ארגומנטים, או שנצטרך לבצע סדרה וסיריאליזציה של נתונים מסוגים לא ידועים. זה המקום שבו נעשה שימוש בחבילת reflect בגולנג.
Reflect Package ב-Go
חבילת reflect מספקת סט של פונקציות המאפשרות לנו לבדוק ולתפעל ערכים בזמן ריצה, ללא קשר לסוגיהם. בעזרת פונקציות אלו, אנו יכולים לקבל מידע על הסוג והערך של כל משתנה, ליצור מופעים חדשים של סוגים ולשנות את הערך של משתנים קיימים.
חבילת reflect בגולנג מכילה שני סוגים: סוג וערך. סוג מייצג סוג Go, כגון int, מחרוזת או מבנה מותאם אישית. ערך מייצג ערך מסוג מסוים, כגון 42 או 'שלום'.
חבילת reflect מספקת גם קבוצה של פונקציות המאפשרות לנו להשיג אובייקטים מסוג Type ו- Value ממשתנים. לדוגמה, הפונקציה reflect.TypeOf() מחזירה אובייקט Type המייצג את הסוג של משתנה, בעוד שהפונקציה reflect.ValueOf() נותנת אובייקט Value המציג ערך משתנה.
בסעיפים הבאים, נחקור כמה מהפונקציות הנפוצות בחבילת reflect.
פונקציית reflect.Copy()
הפונקציה reflect.Copy() של חבילת reflect משמשת להעתקת הערכים של פרוסה אחת לפרוסה אחרת. זה דורש שני פרמטרים, dst ו-src, שניהם חייבים להיות ערכי פרוסה עם אותו סוג אלמנט. הפונקציה מעתיקה את הערכים מפרוסת src לפרוסת dst ומחזירה את מספר האלמנטים שהועתקו.
הפונקציה reflect.Copy() מודגמת בדוגמה הבאה:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'משקף'
)
func רָאשִׁי () {
src := [] int { 1 , 2 , 3 , 4 , 5 }
dst := עשה ([] int , רק ( src ))
נ := משקף . עותק ( משקף . ערך של ( dst ), משקף . ערך של ( src ))
fmt . Println ( נ ) // פלט: 5
fmt . Println ( dst ) // פלט: [1 2 3 4 5]
}
בדוגמה זו, אנו יוצרים פרוסת מקור src עם כמה ערכי מספר שלמים, ופרוסת יעד dst באורך זהה ל-src. לאחר מכן אנו קוראים reflect.Copy() כדי להעתיק את הערכים מ-src ל-dst ולהדפיס את מספר האלמנטים שהועתקו (n) ואת התוכן של פרוסת dst.
פונקציית reflect.DeepEqual()
הפונקציה reflect.DeepEqual() של חבילת reflect משמשת להשוואת שני ערכים עבור שוויון. לפונקציה זו יש שני פרמטרי קלט שהם a ו-b, שניהם יכולים להיות בכל ערך מכל סוג. הפונקציה מחזירה true אם a ו-b שווים באופן עמוק, כלומר הערכים הבסיסיים שלהם שווים רקורסיבית. אחרת, מתברר שזה שקר.
הדוגמה הבאה מראה כיצד להשתמש reflect.DeepEqual():
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'משקף'
)
func רָאשִׁי () {
א := [] int { 1 , 2 , 3 }
ב := [] int { 1 , 2 , 3 }
אם משקף . DeepEqual ( א , ב ) {
fmt . Println ( 'a ו-b שווים' )
} אַחֵר {
fmt . Println ( 'a ו-b אינם שווים' )
}
}
בדוגמה זו, אנו יוצרים שתי פרוסות a ו-b עם אותם ערכים שלמים. לאחר מכן אנו קוראים reflect.DeepEqual() כדי להשוות בין a ו-b לשוויון ולהדפיס את התוצאה.
פונקציית reflect.Swapper()
הפונקציה reflect.Swapper() של חבילת reflect משמשת להחזרת פונקציה שיכולה להחליף את הרכיבים של פרוסה. זה דורש פרמטר בודד, v, שחייב להיות ערך פרוסה. הפונקציה מחזירה פונקציה שלוקחת שני פרמטרים שלמים, i ו-j, ומחליפה את רכיבי הפרוסה בעמדות i ו-j.
ניתן להדגים את השימוש ב-reflect.Swapper() באמצעות הדוגמה הבאה:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'משקף'
)
func רָאשִׁי () {
ס := [] int { 1 , 2 , 3 , 4 , 5 }
לְהַחלִיף := משקף . מחליף ( ס )
לְהַחלִיף ( 1 , 3 )
fmt . Println ( ס ) // פלט: [1 4 3 2 5]
}
בדוגמה זו, יצרנו פרוסה בשם s עם כמה ערכי מספר שלמים. לאחר מכן אנו קוראים reflect.Swapper() כדי לקבל החלפת פונקציה שיכולה להחליף אלמנטים של הפרוסה. אנו משתמשים ב-swap כדי להחליף את האלמנטים בעמדות 1 ו-3 של פרוסת ה-s ולהדפיס את התוצאה.
reflect.TypeOf() פונקציה
ה- reflect.TypeOf() משמש כדי לקבל את סוג הערך. פונקציה זו מקבלת פרמטר יחיד 'v' שיכול להיות מכל סוג או ערך. הפונקציה מחזירה ערך reflect.Type המייצג את סוג הערך.
ניתן להדגים את השימוש ב-reflect.TypeOf() באמצעות הדוגמה הבאה:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'משקף'
)
func רָאשִׁי () {
היה איקס לצוף64 = 3 . 14
ט := משקף . סוג של ( איקס )
fmt . Println ( ט ) // פלט: float64
}
בדוגמה זו, אנו יוצרים משתנה float64 x עם הערך 3.14. לאחר מכן אנו קוראים reflect.TypeOf() כדי לקבל את סוג x ולאחסן את התוצאה במשתנה reflect.Type t. אנו מדפיסים את הערך של t, שהוא float64.
reflect.ValueOf() פונקציה
ה-reflect.ValueOf() יכול לקבל ייצוג reflect.Value של ערך. זה דורש פרמטר יחיד v, שיכול להיות כל ערך מכל סוג. הפונקציה מחזירה ערך reflect.Value המייצג את הערך של פרמטר הקלט.
ניתן להדגים את השימוש ב-reflect.ValueOf() באמצעות הדוגמה הבאה:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'משקף'
)
func רָאשִׁי () {
היה איקס לצוף64 = 3 . 14
ב := משקף . ערך של ( איקס )
fmt . Println ( ב ) // פלט: 3.14
}
בדוגמה זו, אנו יוצרים משתנה float64 x עם הערך 3.14. לאחר מכן אנו קוראים reflect.ValueOf() כדי לקבל ייצוג ערך reflekt של x ומאחסנים את התוצאה במשתנה ערך משקף v. נדפיס את הערך של v, שהוא 3.14.
חבילת reflect מספקת פונקציות רבות מעבר לאלו שהוזכרו, ואלה הן רק כמה דוגמאות. על ידי שימוש בפונקציות המסופקות על ידי חבילת reflect, אנו יכולים ליצור קוד שיכול לעבוד עם ערכים מכל סוג, ללא צורך לדעת את הסוג בזמן הקומפילציה.
סיכום
Reflection in Golang מאפשר לתוכנית לבחון ולשנות מבני נתונים, סוגים וערכים בזמן ריצה. זה מיושם באמצעות חבילת reflect, המספקת פונקציות לבדיקה ולטפל בסוגים וערכים. השתקפות שימושית במיוחד כאשר עובדים עם ממשקים, סוגים לא ידועים, או כאשר אתה צריך ליישם פונקציות כלליות. מאמר זה דן ביסודות השתקפות בגולנג, כולל חבילת reflect, reflect Type and Value, וסוג וערך דינמיים.