משתנים ב-Golang: var, :=, ערכי אפס ו-shadowing

ל-Go יש שתי דרכים להצהיר על משתנה: var, שעובד בכל מקום, ו-:=, צורה קצרה שעובדת בתוך פונקציות ומסיקה את הטיפוס.

package main

import "fmt"

func main() {
	var city string = "Lisbon" // explicit type and value
	var year = 2026            // type inferred as int
	var score int              // no value: zero value 0
	name := "Ana"              // short declaration, inferred string

	fmt.Println(city, year, score, name)
	fmt.Printf("%T %T %T %T\n", city, year, score, name)
}

לכל משתנה יש טיפוס קבוע שנקבע בזמן הידור. כשנותנים ערך, Go מסיקה ממנו את הטיפוס, כך שכתיבת הטיפוס בנוסף (var city string = "Lisbon") חוקית אבל מיותרת.

var מול :=

הבחירה האידיומטית בתוך פונקציה:

• x := value כשיש ערך התחלתי.
• var x T כשרוצים את ערך האפס, וזה מסמן "ריק בכוונה": var buf bytes.Buffer, var total int.
• var x T = value כשהטיפוס שמוסק הוא לא זה שרוצים, למשל var ratio float64 = 1 (ratio := 1 רגיל היה int).

:= מחוץ לפונקציה היא שגיאת תחביר:

./main.go:5:1: syntax error: non-declaration statement outside function body

ערכי אפס

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

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	var i int
	var f float64
	var b bool
	var s string
	var p *int
	var sl []int
	var m map[string]int
	var pt Point

	fmt.Println(i, f, b, s == "", p, sl == nil, m == nil, pt)
	fmt.Println(len(sl), len(m), m["missing"])
}

APIs טובים ב-Go מתוכננים כך שערך האפס יהיה שימושי: sync.Mutex בערך אפס לא נעול, bytes.Buffer בערך אפס ריק ומוכן, ו-len, range ו-append כולם עובדים על slice שהוא nil. זה שצריך לשים עליו עין הוא ה-map: קריאה מ-map שהוא nil מחזירה ערכי אפס, אבל כתיבה אליו גורמת ל-panic. צרו maps עם make או עם ליטרל לפני ששומרים בהם.

הצהרה על כמה משתנים

package main

import "fmt"

var (
	appName = "inventory"
	version = "1.4.0"
	debug   bool
)

func main() {
	var width, height int = 1920, 1080
	x, y := 3, 4
	first, count := "widget", 12

	fmt.Println(appName, version, debug)
	fmt.Println(width, height, x, y, first, count)

	// swap without a temporary variable
	x, y = y, x
	fmt.Println("after swap:", x, y)
}

הבלוק var ( ... ) מקבץ משתנים קשורים ברמת החבילה. בהצבה מרובה כמו x, y = y, x, כל ביטוי בצד הימני מוערך לפני שמשהו מוצב, ולכן ההחלפה עובדת.

:= עם כמה שמות לא מצהיר מחדש על כלום כל עוד לפחות שם אחד בצד השמאלי חדש. שמות קיימים באותו scope פשוט מקבלים ערך. זה מה שמאפשר לעשות שימוש חוזר ב-err:

f, err := os.Open("a.txt")   // declares f and err
g, err := os.Open("b.txt")   // declares g, assigns to the existing err

אם אף אחד מהשמות לא חדש, זו שגיאה:

./main.go:7:4: no new variables on left side of :=

השתמשו ב-= רגיל כדי להציב ערך במשתנה שכבר קיים.

משתנים שלא בשימוש הם שגיאות

משתנה מקומי שמוצהר אבל אף פעם לא נקרא עוצר את ה-build:

./main.go:9:2: declared and not used: x

זו לא אזהרה שאפשר לכבות. מחקו את המשתנה, השתמשו בו, או, בזמן דיבוג, השתיקו אותו עם המזהה הריק: _ = x. המזהה הריק גם זורק ערכים מוחזרים שלא צריך: _, err := fmt.Println("hi").

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

Scope ו-shadowing

משתנה קיים מההצהרה שלו ועד סוף הבלוק העוטף ({ ... }). := בבלוק פנימי יוצר משתנה חדש, גם אם קיים בחוץ משתנה עם אותו שם. המשתנה החיצוני מוסתר, לא משתנה:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	count := 0
	input := "42"

	if input != "" {
		count, err := strconv.Atoi(input) // new count, only inside this block
		if err != nil {
			fmt.Println("error:", err)
			return
		}
		fmt.Println("inside:", count)
	}

	fmt.Println("outside:", count) // still 0
}

התוכנית מדפיסה inside: 42 ואז outside: 0. ה-:= בתוך ה-if הצהיר גם על count וגם על err כמשתנים חדשים בבלוק הפנימי, כי אף אחד מהם עוד לא היה קיים שם. זה מתקמפל בלי בעיות והוא מקור קלאסי לבאגים של "הערך שלי נעלם".

התיקון הוא להצהיר קודם על err ולהציב עם =:

var err error
count, err = strconv.Atoi(input)

go vet לא מדווח על shadowing כברירת מחדל. ה-analyzer הנפרד shadow כן מדווח, ו-linters כמו golangci-lint יכולים להפעיל אותו.

מתן שמות

• השתמשו ב-camelCase: maxRetries, userID. לא max_retries.
• שמרו ראשי תיבות באותו גודל אותיות: userID, httpClient, parseURL, לא userId.
• שמות קצרים ל-scopes קצרים: i בלולאה, r ל-reader, err לשגיאה. שמות ארוכים ומתארים יותר למשתנים ברמת החבילה.
• שם שמתחיל באות גדולה ברמת החבילה (var Timeout) מיוצא לחבילות אחרות. ראו חבילות וייבוא.

משתנים ברמת החבילה

משתנים שמוצהרים מחוץ לפונקציות חיים לאורך כל התוכנית ומאותחלים לפני ש-main רצה, לפי סדר התלויות. הם נוחים להגדרות ולמטמונים, והם משותפים לכל goroutine. אם יותר מ-goroutine אחת כותבת לאחד מהם, הגנו עליו עם mutex או השתמשו ב-sync/atomic, אחרת יש לכם data race.

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