العبارة 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

الترتيب هو الأخير دخولًا الأول خروجًا (LIFO)، مثل المكدّس. وهذا يطابق طريقة تداخل الموارد: إذا فتحت 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)
}

لاحظ الترتيب: افحص الخطأ أولًا، ثم أجّل. إذا فشلت 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. أما الإغلاق فلا وسائط له؛ يقرأ x عند تنفيذه أخيرًا. اختر الشكل الذي يطابق ما تريد تسجيله.

ينطبق هذا أيضًا على مستقبِلات التوابع. تقيّم defer t.Stop() المتغيّر t فورًا، فإعادة إسناد t لاحقًا لا تغيّر القيمة التي ستُوقَف.

حيلة توقيت شائعة تستخدم هذه القاعدة عمدًا:

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

تُستدعى trace("handle") فورًا (فيمكنها طباعة "enter" وتسجيل وقت البدء)، والدالة التي تعيدها هي ما يُؤجَّل.

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)
}

مع آلاف المسارات تنفد واصفات الملفات. انقل جسم الحلقة إلى دالة خاصة به لتُنفَّذ كل 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() { ... }()) تعمل بالطريقة نفسها عندما تبدو الدالة المساعدة المسمّاة مبالغة.

تعديل القيم المعادة

يُنفَّذ الإغلاق المؤجّل بعد أن تسند عبارة 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

تُنفَّذ الاستدعاءات المؤجّلة أثناء فكّ الـ panic للمكدّس. وهذا المكان الوحيد الذي تفعل فيه recover شيئًا، وهو الطريقة التي يمنع بها الخادم طلبًا سيئًا واحدًا من قتل العملية. التفاصيل في صفحة panic وrecover.

لا تُنفَّذ الاستدعاءات المؤجّلة عندما يخرج البرنامج عبر os.Exit أو log.Fatal. إذا أجّلت main تنظيفًا ثم استدعت os.Exit(1)، يُتخطّى التنظيف.

الكلفة

منذ Go 1.14 يضمّن المترجم معظم عبارات defer مباشرة في الشيفرة (open-coded) فتكلّف بضع نانوثوانٍ. استخدام defer لكل تحرير mutex وإغلاق ملف هو الأسلوب المعتاد. الاستثناء هو defer داخل الحلقات: لا يمكن تضمينها مباشرة فترجع إلى مسار أبطأ، وهذا سبب إضافي لنقل أجسام الحلقات إلى دوال.

أخطاء شائعة

• التأجيل قبل فحص الخطأ. افحص err الصادر عن Open أولًا، ثم defer Close.
• توقّع تنظيف في كل تكرار داخل حلقة. تُنفَّذ defer عند خروج الدالة.
• توقّع أن يرى الوسيط المؤجّل التغييرات اللاحقة. الوسائط تُثبَّت عند سطر defer. استخدم إغلاقًا للقراءة وقت الخروج.
• الاعتماد على defer مع os.Exit. لا تُنفَّذ أبدًا.