טיפוסי נתונים ב-Golang: int, float64, string, bool, byte, rune

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

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

שימו לב ש-'G' מודפס כ-71 עם הטיפוס int32: תו בגרשיים בודדים הוא rune, כלומר מספר (נקודת הקוד ב-Unicode). rune הוא כינוי של int32 (אותו טיפוס בשם נוסף), ולכן %T מדווח int32. באותו אופן byte מדווח uint8.

מספרים שלמים

השתמשו ב-int כברירת מחדל. len() מחזירה int, אינדקסים של slices הם int, ומוני לולאות הם int. בכל פלטפורמה של 64 סיביות int הוא 64 סיביות. פנו לטיפוסים עם גודל מוגדר כשהגודל הוא חלק מחוזה: int32 בפורמט קובץ בינארי, uint8 לבתים גולמיים, int64 לחותמת זמן Unix בננו-שניות.

הימנעו מטיפוסים לא מסומנים (unsigned) עבור כמויות ש"לא יכולות להיות שליליות", כמו ספירות. חיסור מתחת לאפס מתגלגל למספר ענק במקום לייצר מספר שלילי שאפשר היה לתפוס.

גבולות ו-overflow

לחבילת math יש קבוע לכל גבול. בזמן ריצה, חשבון שלמים שחורג מהגבול מתגלגל חזרה בשקט:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

בלי panic ובלי שגיאה: 127 + 1 הופך ל--128. רק ביטויים קבועים נבדקים בזמן קומפילציה (var b int8 = 128 לא מתקמפל). אם overflow אפשרי בנתונים שלכם, בדקו לפני הפעולה או השתמשו ב-math/big.

ליטרלים של מספרים שלמים

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

מספרים עשרוניים (floating-point)

ליטרל עם נקודה עשרונית או מעריך (2.5, 1e6) הוא float64 כברירת מחדל, וחבילת math מקבלת ומחזירה float64. השתמשו בו אלא אם הזיכרון במערך גדול חשוב.

מספרים עשרוניים הם בינאריים, ולכן רוב השברים העשרוניים הם קירובים:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

מכאן נובעים שני כללים. אף פעם אל תשוו מספרים עשרוניים עם == אחרי חישוב. ואף פעם אל תשמרו כסף במספר עשרוני: השתמשו במספר שלם של אגורות, או בספרייה עשרונית.

חילוק מספר עשרוני באפס נותן +Inf, -Inf או NaN במקום panic. חילוק מספר שלם באפס גורם ל-panic בזמן ריצה (runtime error: integer divide by zero), ומחלק שהוא אפס קבוע הוא שגיאת קומפילציה.

ערכים בוליאניים

bool מחזיק true או false, וערך האפס שלו הוא false. Go לא מתייחסת למספרים, למחרוזות ריקות או ל-nil כערכים בוליאניים. if count {} היא שגיאת קומפילציה; כתבו if count > 0 {}. האופרטורים הם &&, || ו-!, ו-&& ו-|| מבצעים הערכה מקוצרת.

מחרוזות

string הוא רצף בתים בלתי ניתן לשינוי, בדרך כלל טקסט UTF-8. len(s) סופר בתים, לא תווים:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é תופס שני בתים ב-UTF-8, ולכן len מדווח 6 עבור חמישה תווים. מחרוזות במירכאות כפולות מעבדות תווי escape כמו \n; מחרוזות גולמיות בגרש הפוך (backquote) לא מעבדות אותם, ויכולות להשתרע על כמה שורות. הדף על מחרוזות מכסה את חבילת strings, והדף על runes ו-bytes מסביר את UTF-8 לעומק.

byte ו-rune

אלה כינויים, לא טיפוסים חדשים: byte ו-uint8 ניתנים להחלפה בלי המרה. השמות אומרים מה המשמעות של המספר.

מספרים מרוכבים

ל-Go יש טיפוסים מרוכבים מובנים, complex64 ו-complex128, עם real, imag וחבילת math/cmplx:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

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

טיפוסים מורכבים וטיפוסי הפניה

הטיפוסים הבסיסיים מתחברים לטיפוסים מורכבים. לכל אחד מהם יש דף משלו:

any הוא כינוי של interface{} (החל מ-Go 1.18) ויכול להחזיק ערך מכל טיפוס.

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

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

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

ההקפדה הזאת היא העיקר: אי אפשר להעביר בטעות UserID למקום שבו מצופה OrderID. המירו במפורש כשזו הכוונה: float64(t). ראו את הדף על המרת טיפוסים לגבי הכללים, ואת פונקציות strconv למעבר בין מספרים למחרוזות.

ערכי אפס

לכל טיפוס יש ערך אפס, שהוא מה שמשתנה מחזיק לפני שהשמתם בו משהו: 0 למספרים, false ל-bool, "" למחרוזות, ו-nil למצביעים, slices, maps, channels, פונקציות ו-interfaces. אין ב-Go משתנים לא מאותחלים.