defer ב-Golang: סדר ביצוע, הערכת ארגומנטים ומלכודות

מה defer עושה

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

package main

import "fmt"

func main() {
	fmt.Println("start")
	defer fmt.Println("deferred 1")
	defer fmt.Println("deferred 2")
	defer fmt.Println("deferred 3")
	fmt.Println("end")
}

פלט:

start
end
deferred 3
deferred 2
deferred 1

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

ניקוי ליד ההשגה

השימוש העיקרי ב-defer הוא לכתוב את הניקוי בשורה שמיד אחרי השגת המשאב, כך ששום מסלול חזרה לא ישכח אותו.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func countLines(path string) (int, error) {
	f, err := os.Open(path)
	if err != nil {
		return 0, err
	}
	defer f.Close()

	n := 0
	sc := bufio.NewScanner(f)
	for sc.Scan() {
		n++
	}
	return n, sc.Err()
}

func main() {
	tmp, err := os.CreateTemp("", "defer-*.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.Remove(tmp.Name())
	fmt.Fprint(tmp, "one\ntwo\nthree\n")
	tmp.Close()

	n, err := countLines(tmp.Name())
	fmt.Println(n, err)

	_, err = countLines("/does/not/exist")
	fmt.Println(err)
}

שימו לב לסדר: קודם בודקים את השגיאה, ורק אחר כך defer. אם os.Open נכשלה, f הוא nil, ודחיית f.Close() לפני הבדיקה הייתה קוראת ל-Close על *os.File שהוא nil (מה שמחזיר שגיאה שאף פעם לא תראו, ומבלבל את מי שקורא את הקוד).

אותה צורה עובדת לנעילות:

mu.Lock()
defer mu.Unlock()

אם הקוד שביניהן נכנס ל-panic, ה-mutex עדיין משתחרר.

ארגומנטים מוערכים מיד

הפונקציה שנדחתה והארגומנטים שלה מוערכים כשהוראת ה-defer רצה. רק הקריאה עצמה מחכה.

package main

import "fmt"

func main() {
	x := 1
	defer fmt.Println("deferred with argument:", x)
	defer func() {
		fmt.Println("deferred closure reads:", x)
	}()
	x = 2
	fmt.Println("x is now", x)
}

פלט:

x is now 2
deferred closure reads: 2
deferred with argument: 1

fmt.Println("...", x) לכדה את הערך 1 בשורת ה-defer. ל-closure אין ארגומנטים; הוא קורא את x כשהוא סוף סוף רץ. בחרו בצורה שמתאימה למה שאתם רוצים לתעד.

זה חל גם על receivers של מתודות. defer t.Stop() מעריך את t מיד, כך שהשמה מחדש ל-t בהמשך לא משנה איזה ערך ייעצר.

טריק מדידת זמן נפוץ משתמש בכלל הזה בכוונה:

func handle() {
	defer trace("handle")() // trace runs now, the returned func runs at exit
	// ...
}

trace("handle") נקראת מיד (היא יכולה להדפיס "enter" ולשמור את זמן ההתחלה), והפונקציה שהיא מחזירה היא זו שנדחית.

defer בתוך לולאה

קריאות defer רצות כשהפונקציה חוזרת, לא בסוף כל איטרציה של הלולאה. בלולאה על הרבה קבצים, זה משאיר כל קובץ פתוח עד שהפונקציה מסתיימת.

for _, path := range paths {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close() // all files stay open until the function returns
	process(f)
}

עם אלפי נתיבים זה מכלה את ה-file descriptors. העבירו את גוף הלולאה לפונקציה משלו כדי שכל defer ירוץ בכל איטרציה:

package main

import (
	"fmt"
	"os"
)

func processFile(path string) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()
	info, err := f.Stat()
	if err != nil {
		return err
	}
	fmt.Println(info.Name(), info.Size(), "bytes")
	return nil
}

func main() {
	dir, err := os.MkdirTemp("", "defer-loop")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir)

	var paths []string
	for i := range 3 {
		p := fmt.Sprintf("%s/file%d.txt", dir, i)
		if err := os.WriteFile(p, make([]byte, i*10), 0o644); err != nil {
			fmt.Println(err)
			return
		}
		paths = append(paths, p)
	}
	for _, p := range paths {
		if err := processFile(p); err != nil {
			fmt.Println(err)
		}
	}
}

כל קריאה ל-processFile סוגרת את הקובץ שלה לפני שהבא נפתח. ליטרל פונקציה שנקרא במקום (func() { ... }()) עובד באותו אופן, כשפונקציית עזר עם שם נראית מוגזמת.

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

closure שנדחה רץ אחרי שהוראת ה-return השימה את התוצאות, והוא יכול לשנות תוצאות בעלות שם לפני שמי שקרא רואה אותן.

package main

import (
	"errors"
	"fmt"
)

func double(n int) (result int) {
	defer func() { result *= 2 }()
	return n // result = n, then the defer doubles it
}

func save() (err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("save failed: %w", err)
		}
	}()
	return errors.New("disk full")
}

func main() {
	fmt.Println(double(5))
	fmt.Println(save())
}

הקוד מדפיס 10 ו-save failed: disk full. עם תוצאה בלי שם, פונקציה שנדחתה עדיין יכולה לרוץ, אבל אין לה דרך לשנות את מה שמוחזר.

תפיסת השגיאה מ-Close

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

func writeReport(path string, data []byte) (err error) {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer func() {
		if cerr := f.Close(); cerr != nil && err == nil {
			err = cerr
		}
	}()
	_, err = f.Write(data)
	return err
}

errors.Join(err, f.Close()) היא חלופה קצרה יותר כשרוצים לדווח על שתי השגיאות.

defer, panic ו-recover

קריאות defer רצות בזמן ש-panic מגולל את המחסנית. זה המקום היחיד שבו recover עושה משהו, וכך שרת מונע מבקשה פגומה אחת להפיל את התהליך. הפרטים נמצאים בדף על panic ו-recover.

קריאות defer לא רצות כשהתוכנית יוצאת דרך os.Exit או log.Fatal. אם main דוחה ניקוי ואז קוראת ל-os.Exit(1), הניקוי מדולג.

עלות

החל מ-Go 1.14, רוב ה-defers מוטמעים ישירות בקוד (open-coded) על ידי הקומפיילר ועולים כמה ננו-שניות. שימוש ב-defer לכל שחרור mutex וסגירת קובץ הוא הסגנון הרגיל. defers בתוך לולאות הם היוצא מן הכלל: אי אפשר להטמיע אותם כך והם עוברים למסלול איטי יותר, וזו עוד סיבה להעביר גופי לולאות לפונקציות.

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

• defer לפני בדיקת השגיאה. בדקו קודם את err מ-Open, ורק אז defer Close.
• לצפות לניקוי בכל איטרציה בלולאה. defers רצים ביציאה מהפונקציה.
• לצפות שארגומנט שנדחה יראה שינויים מאוחרים יותר. הארגומנטים נקבעים בשורת ה-defer. השתמשו ב-closure כדי לקרוא ביציאה.
• להסתמך על defer עם os.Exit. הוא אף פעם לא רץ.