דוגמה 1: ליהוק סוג גולנג בסיסי
נתחיל עם הדוגמה של ליהוק ישיר ובסיסי ב-Go מכיוון שאנו דורשים casting כדי לשנות את סוג המשתנה, בכל מקום.
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
)
func רָאשִׁי () {
היה איקס int = 31
ו := לצוף64 ( איקס )
fmt . Println ( ו )
}
כאן, אנו מתחילים עם הפונקציה הראשית על ידי הכרזה על משתנה בשם 'x' מסוג 'int' ומקצים לו ערך של 31. לאחר מכן, המשתנה 'y' מוכרז באמצעות אופרטור הקצאת הקיצור ':='. הסוג של 'y' נקבע אוטומטית מהביטוי בצד ימין שהוא תוצאה של המרת 'x' ל-'float64'. לכן, בתוכנית זו, הערך של 'x' מומר ל-'float64' ומוקצה ל-'y'.
התוצאות שנשלפות מהליהוק הבסיסי ב-Go מוצגות באופן הבא:
דוגמה 2: ליהוק סוג גולנג מרומז
ליהוק סוג מרומז אסור בין סוגים שונים. Go אוכף הקלדה חזקה, כלומר איננו יכולים להקצות או להשתמש באופן ישיר בערך מסוג אחד כסוג אחר ללא המרה מפורשת. בהמשך, אנו מנסים לבצע את הליהוק המרומז שיוצר את החריגה על ידי Go:
חֲבִילָה רָאשִׁי
יְבוּא 'fmt'
func רָאשִׁי () {
היה מספר שלם int = 9 . 08
fmt . Printf ( 'מספר שלם הוא %g' , מספר שלם )
}
הנה הקוד שמתחיל בפונקציה main() שבה משתנה 'מספר שלם' מוכרז עם הסוג 'int'. הערך שמוקצה למשתנה 'מספר שלם' הוא 9.08 שהוא מספר נקודה צפה. מכיוון שאנו מנסים להקצות ערך של נקודה צפה ישירות למשתנה מספר שלם, זה גורם לשגיאת אי התאמה מסוג. לאחר מכן, אנו משתמשים בפונקציה 'printf' מחבילת 'fmt' כדי להדפיס את הערך של המשתנה 'שלם' באמצעות מפרט הפורמט '%g'.
כצפוי, הליהוק המרומז אינו מקובל בגולנג. הליהוק הקודם של הסוג המרומז מייצר את השגיאה הבאה:
דוגמה 3: ליהוק סוג גולנג מפורש
המרת הסוג המפורש מאפשרת לנו להמיר בבטחה את הערכים בין סוגים תואמים תוך הצהרה מפורשת של כוונה. זה מבטיח שאנחנו מודעים להמרת הסוג ומסייע במניעת שגיאות הטיפוס המקריות. שקול את הליהוק המפורש הבא:
חֲבִילָה רָאשִׁייְבוּא 'fmt'
func רָאשִׁי () {
היה floatVal לצוף32 = 6 . 75
היה intVal int = int ( floatVal )
fmt . Printf ( 'ערך צף הוא %g \n ' , floatVal )
fmt . Printf ( 'ערך מספר שלם הוא %d' , intVal )
}
כאן נוצר משתנה 'floatVal' עם הסוג 'float32', והוא מקבל את הערך '6.75'. לאחר מכן, משתנה 'intVal' מוכרז עם הסוג 'int'. כדי להקצות את הערך של floatVal ל-intVal, נעשה שימוש בהמרת הסוג. כדי להפוך את floatVal לערך שלם, הפונקציה 'int' משמשת עם floatVal כקלט. לאחר מכן, ה-“fmt.Printf(“Float Value is %g\n”, floatVal)” מדפיס את הערך של floatVal באמצעות מפרט הפורמט %g המתאים להדפסת ערכי הנקודה הצפה. בעוד שורת הקוד 'fmt.Printf('Integer Value is %d', intVal)' מדפיסה את הערך של intVal באמצעות מפרט הפורמט %d המתאים להדפסת ערכי המספרים השלמים.
הפלט הבא מייצר את הערכים הן עבור floatVal והן עבור intVal לאחר הליהוק:
דוגמה 4: ליהוק סוג גולנג כדי לקבל את הממוצע
לאחר מכן, אנו מבצעים את הליהוק כדי לקבל את המספר הממוצע מהערכים הנתונים. בוא נעבור על קוד המקור שמסופק בקטע הבא:
חֲבִילָה רָאשִׁייְבוּא 'fmt'
func רָאשִׁי () {
היה סה'כ int = 900
היה המספר שלי int = עשרים
היה מְמוּצָע לצוף32
מְמוּצָע = לצוף32 ( סה'כ ) / לצוף32 ( המספר שלי )
fmt . Printf ( 'הממוצע הוא = %f \n ' , מְמוּצָע )
}
כאן, אנו מכריזים בתחילה על שלושה משתנים. ה-'סה'כ הוא משתנה של מספר שלם שמאוחל בערך 900. ה-'MyNumber' הוא משתנה שלם שמאוחל בערך 20. הממוצע המחושב מאוחסן לאחר מכן במשתנה 'ממוצע' float32. לאחר מכן ניתנת הנוסחה הממוצעת לביצוע החישוב. כדי להבטיח שהחלוקה תתבצע כחלוקה של נקודה צפה, הערכים של 'טוטאל' ו-'MyNumber' מומרים ל-float32 באמצעות המרת הסוג. הממוצע המחושב מוקצה למשתנה 'ממוצע'. לבסוף, מחרוזת הפורמט '%f\n' המשמשת בפונקציה 'printf' מציינת שיש להדפיס ערך צף, ואחריו תו חדש.
הערך המתקבל כממוצע מובא לאחר מרמז על יציקת הסוג בקוד הקודם:
דוגמה 5: ליהוק Golang Int וסוג מחרוזת
בנוסף, Go מציעה גם ליהוק בין סוגי Int ו-String. אנו יכולים להשיג זאת באמצעות הפונקציה של חבילת strconv.
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'strconv'
)
func רָאשִׁי () {
היה str חוּט = '1999'
ב , _ := strconv . גְרוֹר ( ס )
fmt . Println ( ב )
היה מספר שלם int = 1999
toStr := strconv . טָבוּעַ ( מספר שלם )
fmt . Println ( toStr )
}
הנה הקוד שמתחיל בהצהרה של שני משתנים. ה- 'str' הוא משתנה מחרוזת שמאוחל עם הערך של '1999' וה-'שלם' הוא משתנה שלם שמאוחל עם הערך של '1999'. לאחר מכן, הפונקציה 'strconv.Atoi()' משמשת להמרת המחרוזת 'str' לערך מספר שלם. הערך המוחזר של 'v' מייצג את המספר השלם שהומר, ומזהה הריק '_' משמש כדי להתעלם מכל שגיאה פוטנציאלית שמוחזרת על ידי Atoi().
לאחר מכן, הפונקציה strconv.Itoa() משמשת כדי להפוך את המספר השלם לערך מחרוזת. הערך המוחזר שהוא 'toStr' מייצג את המחרוזת שהומרה.
הפלט מציג את ההמרה מהמחרוזת '1999' למספר שלם ובחזרה למחרוזת שמייצרת את הערך המקורי של '1999':
דוגמה 6: ליהוק סוג גולנג בין מחרוזת לבייטים
יתרה מכך, הליהוק ב-Go יכול להתבצע גם בסוגי מחרוזת ובייטים. הקודים הבאים מדגימים את ההמרה בין מחרוזות לפרוסות בתים:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
)
func רָאשִׁי () {
היה mystr חוּט = 'שלום'
היה b1 [] בייט = [] בייט ( myStr )
fmt . Println ( b1 )
toString := חוּט ( b1 )
fmt . Println ( toString )
}
כאן, המשתנים מוכרזים לראשונה בתור 'myStr' ו-'b1' אשר מאותחלים עם ערכים מסוימים. לאחר מכן, הביטוי []byte(myStr) ממיר את המחרוזת 'myStr' לפרוסת בתים באמצעות המרת הסוג. הוא מקצה את פרוסת הבייטים המתקבלת למשתנה 'b1'. לאחר מכן, הביטוי 'string(b1)' ממיר את פרוסת הבתים b1 בחזרה למחרוזת באמצעות המרת הסוג. הוא מקצה את המחרוזת המתקבלת למשתנה 'toString'.
הפלט מראה את ההמרה בין המחרוזת 'היי שם' לבין ייצוג פרוסת הבתים המתאים לה בקטע הבא:
דוגמה 7: ליהוק סוג גולנג כדי לקבל את השורש הריבועי
כעת, אנו מבצעים את הליהוק ב-Go כדי למצוא את תוצאות השורש הריבועי. הקוד ממוקם באופן הבא:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'מתמטיקה'
)
func רָאשִׁי () {
היה נ int = 177
היה SqrtN לצוף64
SqrtN = מתמטיקה . Sqrt ( לצוף64 ( נ ))
fmt . Printf ( 'שורש הריבוע של %d הוא %.2f \n ' , נ , SqrtN )
}
כאן, המשתנה 'n' מוכרז כ-int ומקצה את הערך של '144'. המשתנה 'SqrtN' מוכרז כ-float64 ומאחסן את השורש הריבועי המחושב של 'n'. לאחר מכן, הפונקציה math.Sqrt() נפרסת כדי לחשב את השורש הריבועי של 'n'. מאז math.Sqrt() מצפה לארגומנט float64, והערך של 'n' מומר ל-float64 באמצעות float64(n). לאחר מכן, מחרוזת הפורמט 'השורש הריבועי של %d הוא %.2f\n' קוראת לפונקציה 'printf' המציינת ערך מספר שלם (%d) וערך נקודה צפה (%2f). מפרט הדיוק '.2' ב-%2f מבטיח שהשורש הריבועי מודפס בשני מקומות עשרוניים.
מתקבל הפלט הבא המציין את השורש הריבועי של הערך הנתון:
סיכום
הליהוק ב-Go נדון עם דוגמאות ברורות שכולן ניתנות להפעלה. זכור שב-Go, ה-typecasting הוא מפורש אשר אוכף הקלדה חזקה ומקדם בהירות ואמינות קוד.