const ב-Golang: קבועים עם טיפוס ובלי טיפוס

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

package main

import (
	"fmt"
	"time"
)

const AppName = "inventory"
const MaxRetries = 3
const Timeout = 2 * time.Second

const (
	KB = 1024
	MB = 1024 * KB
	GB = 1024 * MB
)

func main() {
	fmt.Println(AppName, MaxRetries, Timeout)
	fmt.Println("1 GB =", GB, "bytes")
	fmt.Printf("upload limit: %.1f MB\n", 15_000_000.0/MB)
}

אפשר להצהיר על קבועים ברמת החבילה או בתוך פונקציה, אחד בכל שורה או מקובצים בבלוק const ( ... ). MB ו-GB מחושבים מקבועים אחרים, והקומפיילר מבצע את החישוב הזה פעם אחת, בזמן הבנייה.

השמה לקבוע, כמו MaxRetries = 5, היא שגיאת קומפילציה:

./main.go:8:2: cannot assign to MaxRetries (neither addressable nor a map index expression)

מה יכול להיות קבוע

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

כל מה שדורש הרצת קוד או הקצאת זיכרון לא נכנס:

const Colors = []string{"red", "green"} // slice
const Started = time.Now()              // function call

./main.go:9:16: []string{…} (value of type []string) is not constant
./main.go:10:13: time.Now() (value of struct type time.Time) is not constant

למה אין ב-Go קבועים מסוג slice או map

slices, maps ו-structs שמכילים אותם הם הפניות לזיכרון שקיים בזמן ריצה, ולכן הקומפיילר לא יכול לצרוב אותם בתוכנית כערכים קבועים, ול-Go אין מאפיין readonly או final למשתנים. הפתרונות המקובלים:

package main

import (
	"fmt"
	"slices"
)

// A package-level var: fine when your own code is the only writer.
var weekdays = []string{"Mon", "Tue", "Wed", "Thu", "Fri"}

// A function returning a fresh copy: callers cannot change the original.
func Weekdays() []string {
	return slices.Clone(weekdays)
}

// An array has a fixed length, but it is still a var, not a const.
var primes = [5]int{2, 3, 5, 7, 11}

func main() {
	days := Weekdays()
	days[0] = "Monday" // changes the copy only

	fmt.Println(days)
	fmt.Println(weekdays)
	fmt.Println(primes, len(primes))
}

ההעתקה עולה הקצאה אחת בכל קריאה, וזה בסדר לנתונים בגודל של קונפיגורציה. לחיפוש לפי מפתח, switch בתוך פונקציה הוא עוד אפשרות שמתנהגת כמו קבוע: func statusText(code int) string { switch code { ... } }.

קבועים בלי טיפוס

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

package main

import "fmt"

const Ratio = 2 // untyped integer constant

func main() {
	var a int = Ratio
	var b float64 = Ratio
	var c uint8 = Ratio
	var d float32 = Ratio * 1.5

	fmt.Println(a, b, c, d)
	fmt.Printf("%T %T %T %T\n", a, b, c, d)

	// When nothing forces a type, the default type is used.
	x := Ratio
	y := Ratio * 1.5
	fmt.Printf("x is %T, y is %T\n", x, y)
}

Ratio עובד כ-int, כ-float64, כ-uint8 וכ-float32 בלי המרה. בגלל זה time.Sleep(2 * time.Second) מתקמפל: 2 הוא בלי טיפוס והופך ל-time.Duration.

כשההקשר לא דורש טיפוס, כמו ב-x := Ratio, הקבוע מקבל את טיפוס ברירת המחדל שלו:

חשבון מדויק

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

package main

import "fmt"

const Huge = 1 << 100
const Scaled = Huge >> 98 // 4: fits in an int

func main() {
	fmt.Println(Scaled)
	fmt.Println(Huge / (1 << 90)) // 1024
}

את Huge עצמו אי אפשר להדפיס כמספר שלם, כי העברתו ל-fmt.Println ממירה אותו ל-int, והקומפיילר תופס את זה (float64(Huge) עובד, כי float יכול להחזיק ערך בסדר הגודל הזה):

cannot use Huge (untyped int constant 1267650600228229401496703205376) as int value in argument to fmt.Println (overflows)

אותה בדיקה עוצרת טעויות קטנות יותר בזמן קומפילציה, כמו var b byte = 300:

cannot use 300 (untyped int constant) as byte value in variable declaration (overflows)

קבועים עם טיפוס

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

const Limit int = 10

var f float64 = 2
fmt.Println(Limit * f)

invalid operation: Limit * f (mismatched types int and float64)

עם const Limit = 10 (בלי טיפוס), Limit * f מתקמפל ונותן 20. לכן השאירו קבועים בלי טיפוס, אלא אם לטיפוס יש משמעות. יש לו משמעות כשמצהירים על קבועים מטיפוס בעל שם משלכם, וכך Go בונה enums:

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

כאן הטיפוס הוא העיקר: פונקציה שמקבלת Weekday מתעדת מה היא רוצה. iota ודפוסי ה-enum שנבנים עליו מוסברים בדף על enums ו-iota.

const מול var

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

מלכודות

קבועים עם טיפוס לא מתאימים את עצמם. אי אפשר להעביר את const Timeout int = 5 למקום שבו מצופה time.Duration בלי המרה; את const Timeout = 5 בלי טיפוס אפשר להכפיל: Timeout * time.Second.

חילוק שלמים מתבצע על קבועים שלמים. const Half = 1 / 2 הוא 0, כי שני האופרנדים הם מספרים שלמים בלי טיפוס. כתבו 1.0 / 2 כדי לקבל 0.5.

אין כתובת. &MaxRetries לא מתקמפל. אם API מצפה ל-*int, העתיקו קודם את הקבוע למשתנה.