فهم الوظائف المجهولة والإغلاق في جولانج

1 مقدمة في الدوال المجهولة

1.1 المقدمة النظرية للدوال المجهولة

الدوال المجهولة هي دوال بدون اسم معلن صراحة. يمكن تعريفها مباشرة واستخدامها في الأماكن التي يُطلب فيها نوع دالة. تُستخدم هذه الدوال كثيرًا لتنفيذ التغليف المحلي أو في الحالات ذات المدى الزمني القصير. بالمقارنة مع الدوال المسماة، الدوال المجهولة لا تحتاج إلى اسم، مما يعني أنه يمكن تعريفها داخل متغير أو استخدامها مباشرة في تعبير.

1.2 تعريف واستخدام الدوال المجهولة

في لغة Go، يكون الصيغة الأساسية لتعريف دالة مجهولة كما يلي:

func(المُدخَلات) {
    // جسم الدالة
}

يمكن تقسيم استخدام الدوال المجهولة إلى حالتين: التعيين إلى متغير أو التنفيذ المباشر.

• التعيين إلى متغير:

sum := func(a int, b int) int {
    return a + b
}

result := sum(3, 4)
fmt.Println(result) // الناتج: 7

في هذا المثال، يتم تعيين الدالة المجهولة إلى المتغير sum، ثم نستدعي sum كأي دالة عادية.

• التنفيذ المباشر (المعروف أيضًا بالدالة المجهولة التنفيذية لنفسها):

func(a int, b int) {
    fmt.Println(a + b)
}(3, 4) // الناتج: 7

في هذا المثال، يتم تنفيذ الدالة المجهولة فور تعريفها، دون الحاجة إلى تعيينها إلى أي متغير.

1.3 أمثلة عملية لتطبيقات الدوال المجهولة

تُستخدم الدوال المجهولة على نطاق واسع في لغة Go، وهنا بعض السيناريوهات الشائعة:

• كدالة اتصال مرجعي: يُستخدم الدوال المجهولة بشكل شائع لتنفيذ منطق المرجع. على سبيل المثال، عندما تأخذ الدالة دالةً أخرى كمتغير، يمكنك تمرير دالة مجهولة.

func traverse(numbers []int, callback func(int)) {
    for _, num := range numbers {
        callback(num)
    }
}

traverse([]int{1, 2, 3}, func(n int) {
    fmt.Println(n * n)
})

في هذا المثال، يتم تمرير الدالة المجهولة كمعلمة مرجعية إلى traverse، ويتم طباعة كل رقم بعد أن يكون قد تم رفعه للتربيع.

• لمهام التنفيذ الفوري: في بعض الأحيان، نحتاج إلى تنفيذ دالة مرة واحدة فقط بالقرب من نقطة التنفيذ. يمكن استدعاء الدوال المجهولة فورًا لتلبية هذا المتطلب وتقليل تكرار الكود.

func main() {
    // ...كود آخر...

    // مجموعة الكود التي تحتاج إلى تنفيذها فورًا
    func() {
        // كود تنفيذ المهمة
        fmt.Println("تم تنفيذ الدالة المجهولة فورًا.")
    }()
}

هنا، يتم تنفيذ الدالة المجهولة فورًا بعد التعريف، وتُستخدم لتنفيذ مهمة صغيرة بسرعة دون الحاجة إلى تعريف دالة جديدة خارجيًا.

• الإغلاقات: يُستخدم الدوال المجهولة عادة لإنشاء الإغلاقات لأنها يمكن أن تستولي على المتغيرات الخارجية.

func sequenceGenerator() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

في هذا المثال، تُرجع sequenceGenerator دالة مجهولة تستولي على المتغير i، وكل مكالمة ستزيد i.

من الواضح أن مرونة الدوال المجهولة تلعب دورًا مهمًا في البرمجة الفعلية، مما يبسط الكود ويحسن قراءته. في الأقسام القادمة، سنناقش الإغلاقات بتفصيل، بما في ذلك خصائصها وتطبيقاتها.

2 فهم عميق للإغلاقات

2.1 مفهوم الإغلاقات

الإغلاق هو قيمة دالة تشير إلى المتغيرات خارج جسم الدالة الخاص بها. يمكن لهذه الدالة الوصول إلى هذه المتغيرات وربطها، مما يعني أنها ليست فقط قادرة على استخدام هذه المتغيرات ولكن أيضًا يمكنها تعديل المتغيرات المشار إليها. الإغلاقات يتم ترتبط عادة بالدوال المجهولة، حيث أن الدوال المجهولة ليس لديها أسماء خاصة بها وغالباً ما يتم تعريفها مباشرة حيثما تكون مطلوبة، وهو ما يخلق بيئة مثل هذه للإغلاقات.

مفهوم الإغلاق لا يمكن فصله عن بيئة التنفيذ والنطاق. في لغة Go، يحتوي كل استدعاء للدالة على إطار كومة خاص به، يخزن فيه المتغيرات المحلية للدالة. ومع ذلك، عندما تعود الدالة، فإن إطارها الخاص بالكومة لم يعد موجودًا. سحر الإغلاقات يكمن في أنه حتى بعد أن تعود الدالة الخارجية، يمكن للإغلاق الاستمرار في الإشارة إلى المتغيرات الخارجية للدالة.

func outer() func() int {
    count := 0
    return func() int {
        count += 1
        return count
    }
}

func main() {
    closure := outer()
    println(closure()) // الناتج: 1
    println(closure()) // الناتج: 2
}

في هذا المثال، تُرجع الدالة outer إغلاقًا يشير إلى المتغير count. حتى بعد نهاية تنفيذ الدالة outer، يمكن للإغلاق أن يعدل count.

2.2 العلاقة مع الدوال المجهولة

الدوال المجهولة والإغلاقات مرتبطة بشكل وثيق. في لغة Go ، الدالة المجهولة هي دالة بدون اسم يمكن تعريفها واستخدامها فور الحاجة. هذا النوع من الدوال مناسب بشكل خاص لتنفيذ سلوك الإغلاق.

غالبًا ما يتم تنفيذ الإغلاقات ضمن الدوال المجهولة ، حيث يمكنها التقاط المتغيرات من النطاق الذي تم إنشاؤها فيه. عندما تشير دالة مجهولة إلى متغيرات من النطاق الخارجي ، فإن الدالة المجهولة ، جنبًا إلى جنب مع المتغيرات المشار إليها ، تشكل إغلاقًا.

func main() {
    adder := func(sum int) func(int) int {
        return func(x int) int {
            sum += x
            return sum
        }
    }

    sumFunc := adder()
    println(sumFunc(2))  // Output: 2
    println(sumFunc(3))  // Output: 5
    println(sumFunc(4))  // Output: 9
}

هنا ، تُرجع الدالة adder دالة مجهولة ، مما يشكل إغلاقًا عن طريق الإشارة إلى المتغير sum.

2.3 سمات الإغلاقات

السمة الأكثر وضوحًا للإغلاقات هي قدرتها على تذكر البيئة التي تم إنشاؤها فيها. يمكنها الوصول إلى المتغيرات المعرفة خارج دالتها الخاصة. طبيعة الإغلاقات تسمح لها بتجنيب الحالة (عن طريق الإشارة إلى المتغيرات الخارجية) ، مما يوفر الأساس لتنفيذ العديد من الميزات القوية في البرمجة ، مثل المزينين وتجنيب الحالة والتقدير الكسلي.

بالإضافة إلى تجنيب الحالة ، للإغلاقات السمات التالية:

• تمديد عمر المتغيرات: عمر المتغيرات الخارجية المشار إليها بواسطة الإغلاقات يمتد على مدار فترة وجود الإغلاق.
• تجنيب المتغيرات الخاصة: لا يمكن للطرق الأخرى الوصول مباشرة إلى المتغيرات الداخلية للإغلاقات ، مما يوفر وسيلة لتجنيب المتغيرات الخاصة.

2.4 المشاكل الشائعة والاعتبارات

عند استخدام الإغلاقات ، هناك بعض المشاكل الشائعة والتفاصيل للاعتبار:

• مشكلة ربط المتغير التكراري: استخدام المتغير التكراري مباشرة لإنشاء إغلاق داخل الحلقة قد يسبب مشاكل لأن عنوان المتغير التكراري لا يتغير مع كل تكرار.

for i := 0; i < 3; i++ {
    defer func() {
        println(i)
    }()
}
// قد لا يكون الإخراج المتوقع 0، 1، 2، بل 3، 3، 3

لتجنب هذه المشكلة ، يجب تمرير المتغير التكراري كمعلمة إلى الإغلاق:

for i := 0; i < 3; i++ {
    defer func(i int) {
        println(i)
    }(i)
}
// الإخراج الصحيح: 0، 1، 2

• تسرب الذاكرة الخاص بالإغلاق: إذا كان هناك إغلاق يشير إلى متغير محلي كبير واحتُفظ بهذا الإغلاق لفترة طويلة ، فإن المتغير المحلي لن يتم استرداده ، مما قد يؤدي إلى تسرب الذاكرة.

• مشاكل التنافسية مع الإغلاقات: إذا تم تنفيذ إغلاق بشكل متزامن وكان يشير إلى متغير معين ، فيجب أن يضمن أن هذا الإشارة متزامنة. عادةً ما يكون هناك حاجة لأدوات مزامنة مثل أقفال mutex لضمان ذلك.

فهم هذه المشاكل والاعتبارات يمكن أن يساعد المطورين في استخدام الإغلاقات بشكل أكثر أمانًا وفعالية.