אופרטור טרנרי ב-Golang: למה אין ב-Go ובמה להשתמש

ל-Go אין אופרטור טרנרי. אין cond ? a : b. התחליף האידיומטי הוא פקודת if:

package main

import "fmt"

func main() {
	for _, n := range []int{3, 8} {
		// In C or JavaScript: parity = n % 2 == 0 ? "even" : "odd";
		parity := "odd"
		if n%2 == 0 {
			parity = "even"
		}
		fmt.Println(n, parity)
	}
}

הצהירו על המשתנה עם ערך ברירת המחדל, ואז שנו אותו ב-if. כששני הענפים צריכים עבודה, השתמשו ב-if/else:

var fee int
if member {
	fee = 0
} else {
	fee = computeFee(order)
}

למה Go השאירה אותו בחוץ

ה-FAQ של Go עונה על זה ישירות: המתכננים ראו את האופרטור ?: משמש לעיתים קרובות מדי ליצירת ביטויים מסובכים ובלתי חדירים, והחליטו ש-if/else, אף שהוא ארוך יותר, ברור יותר ללא ספק. שפה צריכה רק מבנה אחד של בקרת זרימה מותנית.

בפועל האופרטור החסר עולה שתיים או שלוש שורות לכל שימוש, ומבטל קטגוריה שלמה של ביטויים מקוננים כמו a ? b ? c : d : e.

חזרה מוקדמת במקום זה

בתוך פונקציה, הצורה הנקייה ביותר מדלגת לעיתים קרובות על המשתנה לגמרי:

package main

import "fmt"

func plural(n int, word string) string {
	if n == 1 {
		return word
	}
	return word + "s"
}

func main() {
	fmt.Println(1, plural(1, "file"))
	fmt.Println(3, plural(3, "file"))
}

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

ערכי ברירת מחדל עם cmp.Or (Go 1.22)

הטרנרי הנפוץ ביותר בשפות אחרות הוא "השתמש בערך הזה, או בחלופה אם הוא ריק": name ? name : "anonymous", או name || "anonymous" ב-JavaScript. Go 1.22 הוסיפה את cmp.Or בדיוק לשם כך. היא מחזירה את הארגומנט הראשון שאינו ערך האפס של הטיפוס שלו:

package main

import (
	"cmp"
	"fmt"
)

func main() {
	name := ""
	fmt.Println(cmp.Or(name, "anonymous"))

	name = "Ana"
	fmt.Println(cmp.Or(name, "anonymous"))

	port := 0
	fmt.Println(cmp.Or(port, 8080))

	// several fallbacks, first non-zero wins
	envValue, configValue := "", "eu-west-1"
	fmt.Println(cmp.Or(envValue, configValue, "us-east-1"))
}

היא מתייחסת לערך האפס כאל "חסר", ולכן היא לא יכולה להבחין בין "הפורט הוא 0 בכוונה" לבין "הפורט לא הוגדר". כשאפס הוא ערך תקין, השתמשו במצביע, ב-bool נפרד או ב-if מפורש.

פונקציית If גנרית, והמלכודת שלה

עם generics (Go 1.18) אפשר לכתוב פונקציה שנראית כמו טרנרי:

func If[T any](cond bool, a, b T) T {
	if cond {
		return a
	}
	return b
}

status := If(ok, "pass", "fail")

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

package main

import "fmt"

func If[T any](cond bool, a, b T) T {
	if cond {
		return a
	}
	return b
}

func expensive(label string) string {
	fmt.Println("  computing", label)
	return label
}

type User struct{ Name string }

func main() {
	fmt.Println("If(true, ...):")
	v := If(true, expensive("a"), expensive("b"))
	fmt.Println("  result:", v)

	var u *User // nil
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("panic:", r)
		}
	}()
	name := If(u != nil, u.Name, "guest") // u.Name is evaluated even though u is nil
	fmt.Println(name)
}

הקריאה הראשונה מחשבת גם את "a" וגם את "b", והשנייה גורמת ל-panic עם nil pointer dereference, למרות שהתנאי false. טרנרי אמיתי היה מעריך רק את הצד שנבחר. לכן:

• לעולם אל תשתמשו בפונקציה כזאת כשאחד הצדדים מבצע dereference למצביע, ניגש לאינדקס של slice או קורא רשומה ב-map שאולי לא קיימת.
• לעולם אל תשתמשו בה כשאחד הצדדים יקר או שיש לו תופעות לוואי.
• לערכים זולים ובטוחים היא עובדת, אבל הרבה סוקרי קוד ב-Go עדיין יבקשו if פשוט.

אפשר להפוך את הענפים לעצלים באמצעות העברת פונקציות, If(ok, func() string { return a }, func() string { return b }), אבל בשלב הזה פקודת ה-if קצרה יותר.

טריקים אחרים, ולמה להימנע מהם

חיפוש ב-map. map[bool]string{true: "yes", false: "no"}[ok] עובד, בונה map ומבצע hashing לתוכו בכל הערכה, ומעריך את שני הערכים. זה קוריוז, לא ניב.

פונקציה שנקראת מיד. פונקציה אנונימית שנקראת במקום נותנת ביטוי:

label := func() string {
	if n > 0 {
		return "positive"
	}
	return "non-positive"
}()

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

בחירת תחליף

הצעות להוסיף ביטוי מותנה עולות באופן קבוע ב-issue tracker של Go ונדחו עד עכשיו. כתבו את ה-if.

label := "odd"
if n%2 == 0 {
	label = "even"
}