פונקציות ב-Golang: הצהרה, קריאה והעברת פונקציות

הצהרה על פונקציה

הצהרת פונקציה היא func, שם, הפרמטרים, טיפוס התוצאה וגוף. הטיפוס בא אחרי שם הפרמטר, לא לפניו.

package main

import "fmt"

func add(a int, b int) int {
	return a + b
}

func greet(name string) {
	fmt.Println("Hello,", name)
}

func main() {
	sum := add(3, 4)
	fmt.Println(sum)
	greet("Gopher")
}

add מקבלת שני ערכי int ומחזירה int. greet לא מחזירה כלום, ולכן בחתימה שלה אין טיפוס תוצאה והגוף שלה לא צריך return.

פונקציה שמצהירה על תוצאה חייבת להסתיים בהוראה מסיימת. אם מסלול כלשהו יכול להגיע לסוגר המסולסל הסוגר בלי לחזור, הקומפיילר עוצר עם missing return.

פרמטרים שחולקים טיפוס

פרמטרים עוקבים מאותו טיפוס יכולים לחלוק שם טיפוס אחד. func add(a, b int) int זהה לחלוטין ל-func add(a int, b int) int. גם שילוב מותר:

func scale(x, y float64, factor int) (float64, float64)

כאן x ו-y הם float64 ו-factor הוא int.

ערכים מוחזרים

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

package main

import "fmt"

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func main() {
	q, r := divmod(17, 5)
	fmt.Println(q, r)
}

הקוד מדפיס 3 2. הזוג (value, error) הוא השימוש הנפוץ ביותר בתכונה הזאת ב-Go, ויש לו דף משלו על ערכים מוחזרים מרובים.

ארגומנטים מועתקים

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

package main

import "fmt"

type Point struct{ X, Y int }

func moveCopy(p Point) {
	p.X = 100
}

func movePtr(p *Point) {
	p.X = 100
}

func fillFirst(s []int) {
	s[0] = 99
}

func main() {
	p := Point{1, 2}
	moveCopy(p)
	fmt.Println(p) // unchanged

	movePtr(&p)
	fmt.Println(p) // changed through the pointer

	nums := []int{1, 2, 3}
	fillFirst(nums)
	fmt.Println(nums) // the slice header was copied, the elements were not
}

הפלט הוא:

{1 2}
{100 2}
[99 2 3]

השורה השלישית מפתיעה אנשים. ערך slice הוא כותרת קטנה (מצביע, אורך, קיבולת). העותק מצביע על אותו מערך בסיס, ולכן כתיבה ל-s[0] כותבת לאיבר של מי שקרא. אבל append בתוך הפונקציה עשויה להקצות מערך חדש, ומי שקרא אף פעם לא רואה את הכותרת החדשה. אם פונקציה מגדילה slice, החזירו את ה-slice החדש. אותו היגיון חל על maps: הפונקציה יכולה להוסיף מפתחות שמי שקרא רואה, כי ערך ה-map מפנה לנתונים משותפים.

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

פונקציות הן ערכים

לפונקציה יש טיפוס, שנכתב בלי השם: func(int, int) int. אפשר לשמור פונקציה במשתנה, לשים אותה ב-map או ב-slice, ולהעביר אותה לפונקציה אחרת.

package main

import (
	"fmt"
	"strings"
)

func apply(xs []int, f func(int) int) []int {
	out := make([]int, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

func double(n int) int { return n * 2 }

func main() {
	fmt.Println(apply([]int{1, 2, 3}, double))

	square := func(n int) int { return n * n }
	fmt.Println(apply([]int{1, 2, 3}, square))

	ops := map[string]func(string) string{
		"upper": strings.ToUpper,
		"lower": strings.ToLower,
	}
	fmt.Println(ops["upper"]("go"), ops["lower"]("GO"))
}

square היא פונקציה אנונימית שהושמה למשתנה. פונקציות אנונימיות יכולות גם לקרוא ולשנות משתנים מההיקף שסביבן, וזה הופך אותן ל-closures.

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

type Transform func(int) int

func apply(xs []int, f Transform) []int

ערך האפס של טיפוס פונקציה הוא nil. קריאה לפונקציה שהיא nil גורמת ל-panic עם invalid memory address or nil pointer dereference, ולכן בדקו callbacks אופציונליים לפני שקוראים להם. אפשר להשוות ערכי פונקציה רק ל-nil, אף פעם לא זה לזה.

רקורסיה

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

package main

import "fmt"

func factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	for i := range 6 {
		fmt.Println(i, factorial(i))
	}
}

for i := range 6 סופר מ-0 עד 5 ודורש Go 1.22 ומעלה.

מה שאין לפונקציות ב-Go

• אין overloading. שתי פונקציות באותה חבילה לא יכולות לחלוק שם, גם עם פרמטרים שונים.
• אין ארגומנטים עם ערך ברירת מחדל או ארגומנטים בעלי שם. כל פרמטר מועבר בכל קריאה, לפי הסדר. struct של קונפיגורציה נותן לכם שדות בעלי שם ואופציונליים: NewServer(Config{Port: 8080}).
• אין פונקציות בעלות שם מקוננות. בתוך גוף פונקציה אפשר להצהיר רק על פונקציות אנונימיות, שבדרך כלל מושמות למשתנה.

רשימות ארגומנטים באורך משתנה נתמכות באמצעות פונקציות variadic.

פונקציות מיוצאות ולא מיוצאות

פונקציה ששמה מתחיל באות גדולה (Parse) היא מיוצאת, ואפשר לקרוא לה מחבילות אחרות. שם באות קטנה (parse) גלוי רק בתוך החבילה שלו. אין מילות מפתח public או private; האות הגדולה היא הכלל כולו.

טעויות נפוצות

• לצפות ששינוי בפרמטר יגיע למי שקרא. השמה לפרמטר משנה רק את העותק. החזירו את הערך החדש או קבלו מצביע.
• הוספה עם append בתוך פונקציה והתעלמות מהתוצאה. func add(s []int) { s = append(s, 1) } לא משפיעה על האורך של ה-slice של מי שקרא. כתבו func add(s []int) []int והשתמשו ב-s = add(s).
• תוצאות שלא נעשה בהן שימוש. Go מאפשרת להתעלם מערך מוחזר. go vet לא מסמן שגיאה שנזרקה, אבל linters כמו errcheck (חלק מ-golangci-lint) כן. השתמשו ב-_ = רק כשההתעלמות היא החלטה.