المؤشّر هو عنوان يشير إلى موقع في الذاكرة، وتُستخدم المؤشرات عادةً للسماح للدوالّ أو هياكل البيانات بالحصول على معلومات عن الذاكرة وتعديلها دون الحاجة إلى نسخ الذاكرة المشار إليها، والمؤشّرات قابلة للاستخدام سواءٌ مع الأنواع الأوليّة (المٌضمّنة) أو الأنواع التي يعرّفها المستخدم.

تتضمن البرامج المكتوبة بلغة جو عادةً دوالًا وتوابعًا Methods نمرر لها بيانات مثل وسطاء، ونحتاج أحيانًا إلى إنشاء نسخة محلية من تلك البيانات بحيث تظل النسخة الأصلية من البيانات دون تغيير. مثلًا، لو كان لديك برنامج يمثّل مصرفًا bank، وتريد أن يُظهر هذا البرنامج التغيرات التي تطرأ على رصيد المستخدم تبعًا للخطة التوفيرية التي يختارها، فهنا قد تحتاج إلى بناء دالة تنجز هذا الأمر من خلال تمرير الرصيد الحالي للمستخدم إضافةً إلى الخطة التي يريدها. لا نريد هنا تغيير الرصيد الأساسي وإنما نريد فقط إظهار التعديل الذي سيطرأ على الرصيد، وبالتالي يجب أن نأخذ نسخةً من رصيد المستخدم مثل وسيط للدالة ونعدّل على هذه النسخة. تسمى هذه النسخة نسخةً محلية، وندعو عملية التمرير هذه "التمرير بالقيمة passing by value" لأننا لانرسل المتغير نفسه وإنما قيمته فقط.

هناك حالات أخرى قد تحتاج فيها إلى تعديل البيانات الأصلية؛ بمعنى آخر قد نحتاج إلى تغيير قيمة المتغير الأصلي مباشرةً من خلال الدالة، فمثلًا، عندما يودع المستخدم رصيدًا إضافيًّا في حسابه، فهنا تحتاج إلى جعل الدالة قادرةً على تعديل قيمة الرصيد الأصلي وليس نسخةً منه (نحن نريد إضافة مال إلى رصيده السابق). ليس ضروريًا هنا تمرير البيانات الفعلية إلى الدالة، إذ يمكنك ببساطة إخبار الدالة بالمكان الذي توجد به البيانات في الذاكرة من خلال "مؤشر" يحمل عنوان البيانات الموجودة في الذاكرة. لا يحمل المؤشر القيمة، وإنما فقط عنوان أو مكان وجود القيمة، وتتمكن الدالة من خلال هذا المؤشر من التعديل على البيانات الأصلية مباشرةً. يسمى هذا "التمرير بالمرجع passing by reference"، لأن قيمة المتغير لا تُمرّر إلى الدالة، بل إلى موقعها فقط.

سننشئ في هذا المقال المؤشرات ونستخدمها لمشاركة الوصول إلى الذاكرة المُخصصة لمتغير ما.

تعريف واستخدام المؤشرات

يوجد عنصرا صيغة مختلفان يختصان باستخدام مؤشّر لمتغيرٍ variable ما، وهما: معامل العنونة Address-of operator وهو "&" الذي يعيد عنوان المتغيّر الذي يوضع أمامه في الذاكرة، ومعامل التحصيل Dereference، وهو "*" الذي يعيد قيمة المتغير الموجود في العنوان المحدّد بواسطة عامله.

ملاحظة: يُستخدم رمز النجمة * أيضًا للتصريح عن مؤشّر لمجرد التوضيح بأنه مؤشر، ولا ينبغي أن تخلط بينه وبين عامل التحصيل الذي يُستخدم للحصول على القيمة الموجودة في عنوان محدّد، فهما شيئان مختلفان مُمثّلان بنفس الرمز.

مثال:

var myPointer *int32 = &someint

صرّحنا هنا عن متغير يُسمّى myPointer يُمثّل مؤشرًا لمتغير من نوع العدد الصحيح int32، وهيأنا المؤشر بعنوان someint، فالمؤشر هنا يحمل عنوان المتغير int32 وليس قيمته.

دعنا نلقي الآن نظرةً على مؤشر لسلسلة، إذ تُصرّح الشيفرة التالية عن متغير يُمثّل سلسلة ومتغير آخر يُمثّل مؤشرًا على تلك السلسلة:

package main

import "fmt"

func main() {
    var creature string = "shark"
    var pointer *string = &creature

    fmt.Println("creature =", creature)
    fmt.Println("pointer =", pointer)
}

شغّل البرنامج بالأمر التالي:

$ go run main.go

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

creature = shark
pointer = 0xc0000721e0

عرّفنا المتغير الأول creature من النوع string وهيّأناه بالقيمة shark. أنشأنا أيضًا متغيرًا يُسمّى pointer يُمثّل مؤشرًا على عنوان متغير سلسلة نصية، أي يحمل عنوان متغير نوعه string، وهيّأناه بعنوان السلسلة النصية المُمثّلة بالمتغير creature وذلك من خلال وضع المعامل "&" قبل اسمه.

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

يمكنك الوصول إلى قيمة المتغير مباشرةً من خلال نفس المؤشر باستخدام معامل التحصيل "*" كما يلي:

package main

import "fmt"

func main() {
    var creature string = "shark"
    var pointer *string = &creature

    fmt.Println("creature =", creature)
    fmt.Println("pointer =", pointer)

    fmt.Println("*pointer =", *pointer)
}

ويكون الخرج على النحو التالي:

creature = shark
pointer = 0xc000010200
*pointer = shark

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

package main

import "fmt"

func main() {
    var creature string = "shark"
    var pointer *string = &creature

    fmt.Println("creature =", creature)
    fmt.Println("pointer =", pointer)

    fmt.Println("*pointer =", *pointer)

    *pointer = "jellyfish"
    fmt.Println("*pointer =", *pointer)
}

وسيكون الخرج على النحو التالي:

creature = shark
pointer = 0xc000094040
*pointer = shark
*pointer = jellyfish

لاحظ أننا في السطر "pointer = "jellyfish* وضعنا معامل التحصيل * قبل المؤشر للإشارة إلى أننا نريد تعديل القيمة التي يُشير إلى عنوانها المؤشر. أسندنا القيمة "jellyfish" إلى موقع الذاكرة التي يُِشير لها pointer، وهذا يُكافئ تعديل قيمة المتغير creature. لاحظ أنه عند طباعة القيمة التي يُشير لها المؤشر سنحصل على القيمة الجديدة.

كما ذكرنا؛ فهذا يُكافئ تعديل قيمة المتغير creature، وبالتالي لو حاولنا طباعة قيمة المتغير creature سنحصل على القيمة "jellyfish" لأننا نُعدّل على الموقع الذاكري نفسه. سنضيف الآن سطرًا يطبع قيمة المتغير creature إلى الشيفرة السابقة:

package main

import "fmt"

func main() {
    var creature string = "shark"
    var pointer *string = &creature

    fmt.Println("creature =", creature)
    fmt.Println("pointer =", pointer)

    fmt.Println("*pointer =", *pointer)

    *pointer = "jellyfish"
    fmt.Println("*pointer =", *pointer)

    fmt.Println("creature =", creature)
}

وسيكون الخرج كما يلي:

creature = shark
pointer = 0xc000010200
*pointer = shark
*pointer = jellyfish
creature = jellyfish

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

ضع في الحسبان أننا نطبع قيمة المؤشر لتوضيح أنه مؤشر، فلن تستخدم عمليًا قيمة المؤشر إلا للإشارة إلى القيمة الأساسية لاستردادها أو تعديلها.

مستقبلات مؤشرات الدوال

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

يمكنك الاطلاع على المقالة التالية إذا أردت معرفة المزيد عن الدوال وطرق استدعائها في لغة جو.

يمكنك طبعًا تمرير أي وسيط بالطريقة التي تُريدها (بالقيمة أو بالمرجع)، فهذا يعتمد على ما تحتاجه؛ فإذا كنت تريد أن تُعدّل الدالة على البيانات الأصلية نُمرر الوسيط بالمرجع وإلا بالقيمة.

لمعرفة الفرق بدقة، دعنا أولًا نلقي نظرة على دالة تمرّر وسيطًا بالقيمة:

package main

import "fmt"

type Creature struct {
    Species string
}

func main() {
    var creature Creature = Creature{Species: "shark"}

    fmt.Printf("1) %+v\n", creature)
    changeCreature(creature)
    fmt.Printf("3) %+v\n", creature)
}

func changeCreature(creature Creature) {
    creature.Species = "jellyfish"
    fmt.Printf("2) %+v\n", creature)
}

ويكون الخرج على النحو التالي:

1) {Species:shark}
2) {Species:jellyfish}
3) {Species:shark}

أنشأنا بدايةً نوع بيانات مخصص أسميناه Creature، يحتوي على حقل واحد يُسمى Species من نوع سلسلة نصية string، وأنشأنا داخل الدالة الرئيسية main متغير من النوع Creature اسمه creature وأسندنا السلسلة shark إلى الحقل Species. بعد ذلك طبعنا المتغير creature لإظهار القيمة التي يتضمنها في الوقت الحالي، ثم مرّرنا المتغير creature (تمرير بالقيمة أي نُسخة) إلى الدالة changeCreature والتي بدورها تطبع قيمة المتغير المُمرر لها بعد إسناد السلسلة "jellyfish" إلى الحقل Species (هنا نطبعه من داخل الدالة أي محليًّا). بعد ذلك طبعنا قيمة المتغير creature مرةً أخرى (خارج الدالة السابقة).

لاحظ أنه يوجد لدينا ثلاث تعليمات طباعة؛ جرى السطر الأول والثالث من الخرج ضمن نطاق الدالة main بينما كان السطر الثاني ضمن نطاق الدالة changeCreature. لاحظ أيضًا أنه في البداية كانت قيمة المتغير creature هي "shark" وبالتالي عند تنفيذ تعليمة الطباعة الأولى سيطبع:

(1) {Species:shark}

أما تعليمة الطباعة في السطر الثاني والموجودة ضمن نطاق الدالة changeCreature، فسنلاحظ أنها ستطبع القيمة:

(2) {Species:jellyfish}

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

سنأخذ الآن نفس المثال، لكن سنغيّر عملية التمرير إلى الدالة changeCreature لتصبح تمرير بالمرجع، وذلك من خلال تغيير النوع من creature إلى مؤشر باستخدام المعامل "*"، فبدلًا من تمرير creature، سنمرّر الآن مؤشرًا إلى creature أو creature*. كان creature في المثال السابق من النوع struct ويحتوي قيمة الحقل Species وهي "shark"، أما creature* فهو مؤشر وليس struct، وبالتالي قيمته هي موقع الذاكرة وهذا ما مرّرناه إلى الدالة ()changeCreature. لاحظ أننا نضع المعامل "&" عند تمرير المتغير creature إلى الدالة.

package main

import "fmt"

type Creature struct {
    Species string
}

func main() {
    var creature Creature = Creature{Species: "shark"}

    fmt.Printf("1) %+v\n", creature)
    changeCreature(&creature)
    fmt.Printf("3) %+v\n", creature)
}

func changeCreature(creature *Creature) {
    creature.Species = "jellyfish"
    fmt.Printf("2) %+v\n", creature)
}

ستحصل عند تنفيذ الشيفرة السابقة على الخرج التالي:

1) {Species:shark}
2) &{Species:jellyfish}
3) {Species:jellyfish}

قد تبدو الأمور واضحة الآن، فعندما مرّرنا المتغير creature إلى الدالة changeCreature، كان التمرير بالمرجع، وبالتالي أي تغيير يطرأ على المتغير creature (وهو تغيير قيمة الحقل Species إلى "jellyfish") داخل هذه الدالة، سيكون مُطبّقًا على المتغير الأصلي نفسه الموجود ضمن الدالة main لأننا نُعدّل على نفس الموقع في الذاكرة، وبالتالي ستكون قيمة الخرج لتعليمات الطباعة 2 و 3 مُتطابقة.

قد لا يكون لدينا في بعض الأحيان قيمة مُعرّفة للمؤشر، وهذا قد يحدث لأسباب كثيرة منها ما هو متوقع ومنها لا، وبالتالي قد يسبب لك حالات هلع panic في البرنامج. دعنا نلقي نظرةً على كيفية حدوث ذلك وكيفية التخطيط لتلك المشكلة المحتملة.

التأشير إلى اللاشيء Nil

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

سنُعدّل في البرنامج التالي على البرنامج السابق، بحيث نعرّف مؤشرًا متغيرًا creature من النوع Creature، لكن دون استنساخ للنسخة الحقيقية من Creature ودون إسناد عنوانها إلى المؤشر؛ أي أن قيمة المؤشر هي nil، ولن نستطيع الرجوع إلى أي من الحقول أو التوابع المُعرّفة في النوع Creature. لنرى ماذا سيحدث:

package main

import "fmt"

type Creature struct {
    Species string
}

func main() {
    var creature *Creature

    fmt.Printf("1) %+v\n", creature)
    changeCreature(creature)
    fmt.Printf("3) %+v\n", creature)
}

func changeCreature(creature *Creature) {
    creature.Species = "jellyfish"
    fmt.Printf("2) %+v\n", creature)
}

سيكون الخرج على النحو التالي:

1) <nil>
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x8 pc=0x109ac86]

goroutine 1 [running]:
main.changeCreature(0x0)
        /Users/corylanou/projects/learn/src/github.com/gopherguides/learn/_training/digital-ocean/pointers/src/nil.go:18 +0x26
    main.main()
            /Users/corylanou/projects/learn/src/github.com/gopherguides/learn/_training/digital-ocean/pointers/src/nil.go:13 +0x98
        exit status 2

نلاحظ عند تشغيل البرنامج أن تعليمة الطباعة الأولى 1 نجحت وطبعت قيمة المتغير creature وهي <nil>، لكن عندما وصلنا إلى استدعاء الدالة changeCreature ومحاولة ضبط قيمة الحقل Species، ظهرت حالة هلع في البرنامج نظرًا لعدم إنشاء نسخة من هذا المتغيّر، وأدى هذا إلى محاولة الوصول إلى موقع ذاكري غير موجود أصلًا أو غير مُحدد.

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

نتحقق عادةً من قيمة المؤشر في أي دالة تستقبل مؤشرًا مثل وسيط لها كما يلي:

if someVariable == nil {
    // هنا يمكن أن نطبع أي رسالة تُشير إلى هذه الحالة أو أن نخرج من الدالة
}

يمكنك بذلك التحقق مما إذا كان الوسيط يحمل قيمةً صفريةً أم لا. عند تمرير قيمة صفرية (هنا نقصد nil) قد ترغب في الخروج من الدالة باستخدام تعليمة return أو إعادة رسالة خطأ تخبر المستخدم أن الوسيط الممرّر إلى الدالة أو التابع غير صالح.

تتحقق الشيفرة التالية من وجود قيمة صفرية للمؤشر:

package main

import "fmt"

type Creature struct {
    Species string
}

func main() {
    var creature *Creature

    fmt.Printf("1) %+v\n", creature)
    changeCreature(creature)
    fmt.Printf("3) %+v\n", creature)
}

func changeCreature(creature *Creature) {
    if creature == nil {
        fmt.Println("creature is nil")
        return
    }

    creature.Species = "jellyfish"
    fmt.Printf("2) %+v\n", creature)
}

أضفنا إلى الدالة changeCreature تعليمات لفحص قيمة الوسيط creature فيما إذا كانت صفرية أم لا؛ ففي حال كانت صفرية نطبع "creature is nil" ونخرج من الدالة من خلال تعليمة return، وإلا نتابع العمل في الدالة ونُعدّل قيمة الحقل Species. سنحصل الآن على المخرجات التالية:

1) <nil>
creature is nil
3) <nil>

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

إذا أنشأنا نسخةً من النوع Creature وأُسندت للمتغير creature، سيتغير الخرج بالتأكيد، لأنه أصبح يُشير إلى موقع ذاكري حقيقي:

package main

import "fmt"

type Creature struct {
    Species string
}

func main() {
    var creature *Creature
    creature = &Creature{Species: "shark"}

    fmt.Printf("1) %+v\n", creature)
    changeCreature(creature)
    fmt.Printf("3) %+v\n", creature)
}

func changeCreature(creature *Creature) {
    if creature == nil {
        fmt.Println("creature is nil")
        return
    }

    creature.Species = "jellyfish"
    fmt.Printf("2) %+v\n", creature)
}

سنحصل على الناتج المتوقع التالي:

1) &{Species:shark}
2) &{Species:jellyfish}
3) &{Species:jellyfish}

عندما تتعامل مع المؤشرات، هناك احتمال أن يتعرّض البرنامج لحالة هلع، لذلك يجب عليك التحقق لمعرفة ما إذا كانت قيمة المؤشر صفرية قبل محاولة الوصول إلى أي من الحقول أو التوابع المعرّفة ضمن نوع البيانات الذي يشير إليه.

دعنا نلقي نظرةً على كيفية استخدام المؤشرات مع التوابع.

مستقبلات مؤشرات التوابع

المُستقبل receiver في لغة جو هو الوسيط الذي يُعرّف عند التصريح عن التابع. ألقِ نظرةً على الشيفرة التالية:

type Creature struct {
    Species string
}

func (c Creature) String() string {
    return c.Species
}

المُستقبل في هذا التابع هو c Creature، وهو يُشير إلى أن نسخة المتغير c من النوع Creature وأنك ستستخدمه ليُشير إلى نسخة متغير من هذا النوع.

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

دعنا نضيف التابع Reset للنوع Creature، الذي يسند سلسلةً نصيةً فارغة إلى الحقل Species.

package main

import "fmt"

type Creature struct {
    Species string
}

func (c Creature) Reset() {
    c.Species = ""
}

func main() {
    var creature Creature = Creature{Species: "shark"}

    fmt.Printf("1) %+v\n", creature)
    creature.Reset()
    fmt.Printf("2) %+v\n", creature)
}

إذا شغّلت البرنامج ستحصل على الخرج:

1) {Species:shark}
2) {Species:shark}

لاحظ أنه على الرغم من ضبطنا قيمة الحقل Species على السلسلة الفارغة في التابع Reset، إلا أننا عندما طبعنا المتغير creature في الدالة main حصلنا على "shark". السبب في عدم انتقال التغيير هو استخدامنا مُستقبل قيمة في تعريف التابع Reset، وبالتالي سيكون لهذا التابع إمكانية التعديل فقط على نسخة المتغير creature وليس المتغير الأصلي. بالتالي، إذا أردنا تحديث هذه القيمة؛ أي التعديل على النسخة الأصلية للمتغير، فيجب علينا تعريف مُستقبل مؤشر.

package main

import "fmt"

type Creature struct {
    Species string
}

func (c *Creature) Reset() {
    c.Species = ""
}

func main() {
    var creature Creature = Creature{Species: "shark"}

    fmt.Printf("1) %+v\n", creature)
    creature.Reset()
    fmt.Printf("2) %+v\n", creature)
}

لاحظ أننا أضفنا المعامل "*" أمام النوع Creature عندما صرّحنا عن التابع Reset، وهذا يعني أن الوسيط الذي نُمرره أصبح مؤشرًا، وبالتالي أصبحت كل التعديلات التي نُجريها من خلاله مُطبّقةً على المتغير الأصلي.

1) {Species:shark}
2) {Species:}

لاحظ أن التابع Reset عدّل قيمة الحقل Species كما توقعنا، وهذا مُماثل لفكرة التمرير بالمرجع أو القيمة في الدوال.

خاتمة

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

ترجمة -وبتصرف- للمقال Understanding Pointers in Go لصاحبه Gopher Guides.

• المقال السابق: استخدام وسوم البناء لتخصيص الملفات التنفيذية Binaries في لغة جو Go
• المؤشرات Pointers في لغة سي C
• المؤشرات Pointers في لغة Cpp

وسم البناء Build tag أو قيد البناء Build constraint هو مُعرّف يُضاف إلى التعليمات البرمجية لتحديد متى يجب تضمين ملف ما في حزمة أثناء عملية البناء build، ويتيح لك إمكانية بناء إصدارات مُختلفة لتطبيقك من نفس التعليمات البرمجية المصدرية والتبديل بينها بطريقة سريعة ومنظمة.

يستخدم العديد من المطورين وسوم البناء لتحسين سير العمل Workflow عند بناء تطبيقات متوافقة مع جميع أنظمة تشغيل الأساسية Cross-platform، مثل البرامج التي تتطلب تغييرات في التعليمات البرمجية لمراعاة الفروقات بين أنظمة التشغيل المختلفة. تُستخدم وسوم البناء أيضًا من أجل اختبار التكامل Integration testing، مما يسمح لك بالتبديل بسرعة بين الشيفرة المتكاملة والشيفرة باستخدام خادم زائف Mock server أو شيفرة اختبارية بديلة Stub، وبين المستويات المختلفة لمجموعات الميزات التي يتضمنها تطبيقك.

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

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

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

ملاحظات:

• التوافق مع أنظمة التشغيل الأساسية Cross-platform: ‏ هو مصطلح يستخدم في علم الحوسبة يشير إلى برامج الحاسوب أو أنظمة التشغيل أو لغات الحاسوب أو لغات البرمجة وتطبيقاتها التي يمكنها العمل على عدة منصات حاسوبية. هناك نوعان رئيسيان من البرمجيات المتوافقة مع أنظمة التشغيل الأساسية، إذ يستلزم الأول بناءه لكل منصة يمكنه العمل عليها، والثاني يمكنه العمل مباشرةً على أي منصة تدعمه.

• اختبار التكامل Integration testing: يمثّل مرحلة اختبار البرامج التي تتكامل فيها الوحدات البرمجية وتُختبر مثل وحدة واحدة متكاملة. يُجرى اختبار التكامل لتقييم مدى امتثال نظام أو مكون برمجي لمتطلبات وظيفية محددة، وغالبًا ما تكون هذه المتطلبات مدونة في توثيق الخاصيات والمتطلبات.

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

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

المتطلبات الأساسية

أن يكون لديك مساحة عمل خاصة في لغة جو، وإذا لم يكن لديك مساحة عمل، اتبع سلسلة المقالات التالية: تثبيت لغة جو Go وإعداد بيئة برمجة محلية على أبونتو Ubuntu، وتثبيت لغة جو وإعداد بيئة برمجة محلية على نظام ماك macOS، وتثبيت لغة جو وإعداد بيئة برمجة محلية على ويندوز.

بناء النسخة المجانية

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

أنشئ مجلدًا باسم التطبيق الخاص بك في مجلد src، وسنستخدم هنا الاسم "app":

$ mkdir app

انتقل إلى المجلد "app" الذي أنشأته:

$ cd app

أنشئ الآن ملف "main.go" داخل مجلد المشروع. استخدمنا هنا محرر النصوص نانو nano لفتح وإنشاء الملف:

$ nano main.go

سنعرّف الآن الإصدار المجاني من التطبيق. انسخ المحتويات التالية إلى ملف main.go:

package main

import "fmt"

var features = []string{
  "Free Feature #1",
  "Free Feature #2",
}

func main() {
  for _, f := range features {
    fmt.Println(">", f)
  }
}

أنشأنا برنامجًا يُصرّح عن شريحة Slice باسم features، تحتوي على سلسلتين نصيتين strings تمثلان ميزات إصدار تطبيقنا المجاني. تستخدم الدالة ()main حلقة for لتنتقل عبر عناصر شريحة الميزات من أجل طباعة جميع الميزات المتاحة على الشاشة.

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

اِبنِ وشغّل البرنامج:

$ go build
$ ./app

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2

طبع البرنامج ميزتين مجانيتين تكملان ميزات الإصدار المجاني من تطبيقنا.

أكملنا الآن الإصدار المجاني المُتمثّل بتطبيق يحتوي على مجموعة ميزات أساسية جدًا. سنبني بعد ذلك شيفرة تمكننا من إضافة مزيدٍ من الميزات إلى التطبيق عند البناء.

إضافة ميزات احترافية باستخدام go build

تجنّبنا حتى الآن إجراء تغييرات على الملف main.go، وذلك لمحاكاة بيئة إنتاج عامة ينبغي فيها إضافة الشيفرة دون تغيير الشيفرة الرئيسية أو كسرها.

ونظرًا لإمكانية تعديل ملف main.go، سنحتاج إلى استخدام آلية أخرى لإدخال المزيد من الميزات إلى شريحة features باستخدام وسوم البناء.

سننشئ ملفًا جديدًا باسم "pro.go"، والذي سيستخدم الدالة ()init لإضافة المزيد من الميزات إلى شريحة features:

$ nano pro.go

أضف المحتويات التالية إلى الملف بعد فتحه:

package main

func init() {
  features = append(features,
    "Pro Feature #1",
    "Pro Feature #2",
  )
}

استخدمنا الدالة ()init لتشغيل الشيفرة قبل الدالة ()main في التطبيق، ثم استخدمنا الدالة ()append لإضافة ميزات احترافية إلى شريحة features.

احفظ الملف واخرج منه، ثم صرّف التطبيق وشغّله باستخدام الأمر التالي:

$ go build

نظرًا لوجود ملفين الآن في المجلد الحالي، هما "pro.go" و "main.go"، سينشئ الأمر go build ملفًا ثنائيًا من كليهما:

$ ./app

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2
> Pro Feature #1
> Pro Feature #2

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

إضافة وسوم البناء

يمكنك الآن استخدام وسوم البناء لتمييز الإصدار الاحترافي عن المجاني. يكون شكل الوسم كما يلي:

// +build tag_name

من خلال وضع هذا السطر البرمجي في بداية الحزمة الخاصة بك (في أول سطر) وتبديل tag_name إلى اسم وسم البناء الذي تريده، ستُوسّم هذه الحزمة لتصبح شيفرةً يمكن تضمينها اختياريًّا في الثنائي النهائي. دعنا نرى هذا عمليًا عن طريق إضافة وسم البناء إلى ملف pro.go لإخبار الأمر go build بتجاهلها ما لم يُحدّد الوسم. افتح الملف في محرر النصوص الخاص بك:

$ nano pro.go

ضِف مايلي:

// +build pro

package main

func init() {
  features = append(features,
    "Pro Feature #1",
    "Pro Feature #2",
  )
}

أضفنا في بداية الملف pro.go السطر ‎// +build proمتبوعًا بسطر جديد فارغ؛ وهذا السطر الجديد ضروري، وبدونه سيفسّر جو السطر السابق على أنه تعليق. يجب أن تكون تصريحات وسوم البناء أيضًا في أعلى الملف ذي الامتداد "go." دومًا، لا تضع أي شيء، ولا حتى التعليقات قبلها.

يُخبِر التصريح build+ الأمر go build أن هذا ليس تعليقًا، بل هو وسم بناء. الجزء الثاني هو الوسم pro، فبإضافة هذا الوسم في الجزء العلوي من ملف pro.go، سيُضمّن الأمر go build ملف pro.go في حال وجود الوسم pro فقط. صرّف التطبيق الآن وشغّله:

$ go build
$ ./app

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2

بما أن ملف pro.go يتطلب وجود الوسم pro، سيجري تجاهل الملف وسيُصرّف التطبيق دونه.

عند استخدام الأمر go build، يمكننا استخدام الراية tags- لتضمين شيفرة محددة لكي تُصرّف مع التطبيق عن طريق إضافة وسم الشيفرة مثل وسيط. سنجرّب ذلك مع الوسم pro:

$ go build -tags pro

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2
> Pro Feature #1
> Pro Feature #2

سنحصل الآن على الميزات الاحترافية فقط إذا أضفنا الوسم pro.

هذا جيد إذا كان هناك إصدارين فقط، ولكن الأمور تصبح معقدةً عند وجود مزيدٍ من الإصدارات وإضافة مزيدٍ من الوسوم. سنستخدم في الخطوة التالية وسوم بناء متعددة مع منطق بولياني Boolean logic، لإضافة إصدار مُتقدم.

استخدام المنطق البولياني مع وسوم البناء

عندما تكون هناك وسوم بناء متعددة في حزمة جو، تتفاعل الوسوم مع بعضها بعضًا باستخدام المنطق البولياني. لتوضيح ذلك، سنضيف المستوى "مُتقدم Enterprise" لتطبيقنا باستخدام الوسم pro والوسم enterprise.

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

$ nano enterprise.go

ستبدو محتويات enterprise.go متطابقة تقريبًا مع pro.go ولكنها ستحتوي على ميزات جديدة. ضِف الأسطر التالية إلى الملف "enterprise.go":

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

احفظ الملف واخرج.

لا يحتوي ملف enterprise.go حاليًا على أي وسوم بناء، وكما تعلّمت عندما أضفت pro.go، فهذا يعني أن هذه الميزات ستضاف إلى الإصدار المجاني عند تنفيذ go.build. بالنسبة إلى pro.go، أضفت build pro+ \\ متبوعًا بسطر فارغ في أعلى الملف لإخبار الأمر go build أنه يجب تضمينه فقط عند استخدام tags pro-. تحتاج في هذه الحالة فقط إلى وسم بناء واحد لتحقيق الهدف، لكن عند إضافة الميزات الجديدة المتقدمة، إذ يجب أن يكون لديك أولًا ميزات احترافية Pro.

سنجعل الآن ملف enterprise.go يدعم وسم البناء pro. افتح الملف باستخدام محرر النصوص الخاص بك:

$ nano enterprise.go

ضِف بعد ذلك وسم البناء قبل سطر التصريح package main وتأكد من إضافة سطر فارغ كما تحدثنا:

// +build pro

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

احفظ الملف واغلقه، ثم صرّف التطبيق دون إضافة أي وسوم (الإصدار المجاني):

$ go build
$ ./app

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2

لاحظ أن الميزات المتقدمة لا تظهر في الإصدار المجاني. دعنا الآن نضيف وسم الإصدار المحترف pro ونبني التطبيق ونشغّله مرةً أخرى:

$ go build -tags pro
$ ./app

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2
> Enterprise Feature #1
> Enterprise Feature #2
> Pro Feature #1
> Pro Feature #2

ليس هذا فعلًا ما نحتاجه حتى الآن، لأن الميزات المتقدمة تظهر عندما نبني إصدار احترافي، وسنحتاج إلى استخدام وسم بناء آخر لحل هذه المشكلة. بالنسبة للوسم enterprise فهو على عكس الوسم pro، إذ نحتاج هنا إلى التأكد من توفُّر الميزات الاحترافية pro والمتقدمة enterprise في نفس الوقت.

يراعي نظام البناء في جو هذا الموقف من خلال السماح باستخدام بعض المنطق البولياني في نظام وسوم البناء.

لنفتح enterprise.go مرةً أخرى:

$ nano enterprise.go

سنضيف الآن وسمًا إلى هذا الملف باسم enterprise كما فعلنا سابقًا عند إضافة الوسم pro:

// +build pro enterprise

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

احفظ الملف واخرج، ثم صرّف التطبيق مع إضافة الوسم enterprise:

$ go build -tags enterprise
$ ./app

سيكون الخرج على النحو التالي:

> Free Feature #1
> Free Feature #2
> Enterprise Feature #1
> Enterprise Feature #2

لاحظ أننا خسرنا ميزات الإصدار الاحترافي، وسبب ذلك هو أنه عندما نضع عدة وسوم بناء ضمن نفس السطر في ملف "go."، سيفسر go build أن العلاقة بينهما هي OR المنطقية. إذًا، بإضافة السطر build pro enterprise+ \\ سيُبنى الملف enterprise.go في حال وجود إحدى الوسمين pro أو enterprise.

نحن الآن بحاجة إلى كتابة وسوم البناء بطريقة صحيحة مع استخدام المنطق AND، ولفعل ذلك سنكتب كلًا من الوسمين في سطر منفصل، وبهذا الشكل سيفسّر go build على أن العلاقة بينهما AND. افتح الملف enterprise.go مرةً أخرى وافصل وسوم البناء في أسطر منفصلة:

// +build pro
// +build enterprise

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

الآن، صرّف تطبيقك مع الوسم enterprise:

$ go build -tags enterprise
$ ./app

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2

ما زال هذا غير كافي لأن منطق AND يتطلب أن يكون العنصران محققين "true"؛ إذًا نحتاج إلى وجود وسمي البناء pro و enterprise:

$ go build -tags "enterprise pro"
$ ./app

ستحصل على الخرج التالي:

> Free Feature #1
> Free Feature #2
> Enterprise Feature #1
> Enterprise Feature #2
> Pro Feature #1
> Pro Feature #2

يمكنك الآن بناء التطبيق من نفس شجرة المصدر بعدة طرق مختلفة وفقًا للميزات التي تريد توفيرها.

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

خاتمة

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

ترجمة -وبتصرف- للمقال Customizing Go Binaries with Build Tags لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: تعرف على دالة التهيئة init واستخدامها في لغة جو Go
• العمليات الحسابية في لغة جو Go
• مدخل إلى البيانات وأنواعها: أنواع البيانات الأساسية

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

تُستخدم أيضًا عند استيراد تأثير جانبي side effect، وهي تقنية تستخدَم لضبط حالة البرنامج من خلال استيراد حزمة معينة، ويُستخدَم هذا غالبًا لتسجيل register حزمة مع أخرى للتأكد من عمل البرنامج بطريقة صحيحة.

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

سنتعلم في هذا المقال استخدام الدالة ()init لإعداد وتهيئة متغيرات حزمة معيّنة وعمليات حسابية تجرى لمرة واحدة وتسجيل حزمة لاستخدامها مع حزمة أخرى.

المتطلبات

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

.
├── bin 
│ 
└── src
    └── github.com
        └── gopherguides

التصريح عن الدالة ()init

بمجرّد التصريح عن أيّ دالة ()init سيُنفّذها مصرِّف جو قبل أيّ شيفرة أخرى في الحزمة، وسنوضِّح في هذا القسم كيفية تعريف هذه الدالة وكيف تؤثر على تشغيل الحزمة، لذا دعونا الآن نلقي نظرةً على مثال لا يتضمن هذه الدالة:

package main

import "fmt"

var weekday string

func main() {
    fmt.Printf("Today is %s", weekday)
}

صرّحنا في هذا البرنامج عن متغير عام weekday من النوع string، وبما أننا لم نُهيّئ هذا المتغير بأيّ قيمة، فستكون القيمة الافتراضية لها هي السلسلة الفارغة، وبالتالي لن نرى أيّ شيء عند طباعتها، ولنشغّل هذه الشيفرة كما يلي:

$ go run main.go

سيكون الخرج كما يلي:

Today is

يمكننا إعطاء قيمة أوليّة إلى المتغير weekday من خلال الدالة ()init بحيث نُهيّئها بقيمة اليوم الحالي، لذا سنعدِّل على الشيفرة السابقة كما يلي:

package main

import (
    "fmt"
    "time"
)

var weekday string

func init() {
    weekday = time.Now().Weekday().String()
}

func main() {
    fmt.Printf("Today is %s", weekday)
}

استخدمنا في هذه الشيفرة الحزمة time للحصول على اليوم الحالي من خلال كتابة ()Now().Weekday().String ثم استخدمنا الدالة ()init لتهيئة المتغير weekday بها، والآن إذا شغّلنا البرنامج، فسنحصل على خرج مُختلف عن المرة السابقة:

Today is Monday

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

تهيئة الحزم عند استيرادها

بدايةً، سنكتب برنامجًا بسيطًا يختار عشوائيًا عنصرًا من شريحة ما ويطبعها، ولن نستخدِم هنا الدالة ()init لكي نُبيّن المشكلة التي ستحدث وكيف ستحلّها هذه الدالة فيما بعد، لذا أنشئ مجلدًا اسمه creature من داخل المجلد /src/github.com/gopherguides كما يلي:

$ mkdir creature

أنشئ بداخله الملف creature.go:

$ nano creature/creature.go

ضع بداخل الملف التعليمات التالية:

package creature

import (
    "math/rand"
)

var creatures = []string{"shark", "jellyfish", "squid", "octopus", "dolphin"}

func Random() string {
    i := rand.Intn(len(creatures))
    return creatures[i]
}

يُعرِّف هذا الملف متغيرًا يسمى creatures يحتوي على مجموعة من أسماء الكائنات البحرية على أساس قيم لهذه الشريحة، كما يحتوي هذا الملف على دالة عشوائية مُصدّرة تُعيد قيمةً عشوائيةً من هذه الشريحة. احفظ الملف واخرج منه.

سننشئ الآن الحزمة cmd التي سنستخدِمها لكتابة الدالة ()main واستدعاء الحزمة creature، ولأجل ذلك يجب أن نُنشئ مجلدًا اسمه cmd بجانب المجلد creature كما يلي:

$ mkdir cmd

سنُنشئ بداخله الملف main.go:

$ nano cmd/main.go

أضف المحتويات التالية إلى المجلد:

package main

import (
    "fmt"

    "github.com/gopherguides/creature"
)

func main() {
    fmt.Println(creature.Random())
    fmt.Println(creature.Random())
    fmt.Println(creature.Random())
    fmt.Println(creature.Random())
}

استوردنا هنا الحزمة creature، ثم استدعينا الدالة ()creature.Random بداخل الدالة ()main للحصول على عنصر عشوائي من الشريحة وطباعته أربع مرات. احفظ الملف main.go ثم أغلقه.

انتهينا الآن من كتابة الشيفرة، لكن قبل أن نتمكن من تشغيل هذا البرنامج، سنحتاج أيضًا إلى إنشاء ملفَين من ملفات الضبط configuration حتى تعمل التعليمات البرمجية بطريقة صحيحة.

تُستخدَم وحدات لغة جو Go Modules لضبط اعتماديات الحزمة لاستيراد الموارد، إذ تُعَدّ وحدات لغة جو ملفات ضبط موضوعة في مجلد الحزمة الخاص بك والتي تخبر المُصرِّف بمكان استيراد الحزم منه، ولن نتحدث عن وحدات لغة جو في هذا المقال، لكن سنكتب السطرين التاليين لكي تعمل الشيفرة السابقة، لذا أنشئ الملف go.mod ضمن المجلد cmd كما يلي:

$ nano cmd/go.mod

ثم ضع بداخله التعليمات التالية:

module github.com/gopherguides/cmd
 replace github.com/gopherguides/creature => ../creature

يخبر السطر الأول المصرِّف أنّ الحزمة cmd التي أنشأناها هي في الواقع github.com/gopherguides/cmd؛ أما السطر الثاني، فيُخبر المصرِّف أنه يمكن العثور على المجلد github.com/gopherguides/creature محليًا ضمن المجلد creature/..، لذا احفظ وأغلق الملف ثم أنشئ ملف go.mod في مجلد creature:

$ nano creature/go.mod

أضف السطر التالي من التعليمات البرمجية إلى الملف:

module github.com/gopherguides/creature

يخبر هذا المصرِّف أنّ الحزمة creature التي أنشأناها هي في الواقع الحزمة github.com/gopherguides/creature، وبدون ذلك لن تعرف الحزمة cmd مكان استيراد هذه الحزمة. احفظ وأغلق الملف.

يجب أن يكون لديك الآن بنية المجلد التالية:

├── cmd
│   ├── go.mod
│   └── main.go
└── creature
    ├── go.mod
    └── creature.go

الآن بعد أن انتهينا من إنشاء ملفات الضبط اللازمة أصبح بالإمكان تشغيل البرنامج من خلال الأمر التالي:

$ go run cmd/main.go

سيكون الخرج كما يلي:

jellyfish
squid
squid
dolphin

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

للحصول على عشوائية أكبر، يمكننا إعادة ضبط مفتاح توليد الأعداد seed في الحزمة، أو ضبط مصدر متغير بحيث تختلف الحالة الأولية في كل مرة نُشغّل فيها البرنامج، وفي لغة جو من الشائع استخدام الوقت الحالي على أساس مفتاح توليد في حزمة rand، وبما أننا نريد من الحزمة creature التعامل مع دالة عشوائية، افتح هذا الملف:

$ nano creature/creature.go

أضف التعليمات التالية إليه:

package creature

import (
    "math/rand"
    "time"
)

var creatures = []string{"shark", "jellyfish", "squid", "octopus", "dolphin"}

func Random() string {
    rand.Seed(time.Now().UnixNano())
    i := rand.Intn(len(creatures))
    return creatures[i]
}

استوردنا في هذا البرنامج الحزمة time واستخدمنا الدالة ()Seed لضبط مفتاح توليد الأعداد seed في الحزمة إلى وقت التنفيذ آنذاك. احفظ وأغلق الملف.

الآن بتشغيل البرنامج:

$ go run cmd/main.go

ستحصل على ما يلي:

jellyfish
octopus
shark
jellyfish

إذا شغلت البرنامج عدة مرات، فستحصل على نتائج مختلفة في كل مرة، وعمومًا هذا ليس نهجًا مثاليًا لأن الدالة ()creature.Random تُستدعى في كل مرة ولأنه يُعاد ضبط مفتاح توليد الأعداد من خلال الاستدعاء (()rand.Seed(time.Now().UnixNano، وإعادة ضبط مفتاح التوليد re-seeding باستمرار قد يصادف استعمال قيمتين متماثلتين في حالتنا لو استدعي أكثر من مرة بدون تغير الوقت، أي إذا لم تتغير الساعة الداخلية، وهذا سيؤدي إلى تكرار محتمل للنمط العشوائي أو سيزيد من وقت المعالجة في وحدة المعالجة المركزية عن طريق جعل البرنامج ينتظر حتى تتغير الساعة الداخلية، ولحل هذه المشكلة يمكننا استخدام الدالة ()init، لذا سنعدّل الملف creature.go:

$ nano creature/creature.go

أضف ما يلي إلى الملف:

package creature

import (
    "math/rand"
    "time"
)

var creatures = []string{"shark", "jellyfish", "squid", "octopus", "dolphin"}

func init() {
    rand.Seed(time.Now().UnixNano())
}

func Random() string {
    i := rand.Intn(len(creatures))
    return creatures[i]
}

إضافة الدالة ()init ستخبر المصرِّف أنه يجب استدعاؤها عند استيراد الحزمة creature ولمرة واحدة فقط، وبالتالي يكون لدينا مفتاح توليد seed واحد لتوليد العدد العشوائي، ويجنبنا هذا النهج تكرار تنفيذ التعليمات البرمجية، والآن إذا أعدنا تشغيل الشيفرة عدة مرات، فسنحصل على نتائج مختلفة:

$ go run cmd/main.go

سيكون الخرج كما يلي:

dolphin
squid
dolphin
octopus

رأينا في هذا القسم كيف يمكّننا استخدام الدالة ()init من إجراء العمليات الحسابية أو التهيئة المناسبة قبل استخدام الحزمة، وسنرى فيما يلي كيف يمكننا استخدام عدة تعليمات تهيئة ()init في حزمة ما.

استخدام عدة تعليمات من ()init

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

ستُنفّذ عادةً دوال init()‎ بالترتيب نفسه الذي تظهر فيه في الشيفرة مثل ما يلي:

package main

import "fmt"

func init() {
    fmt.Println("First init")
}

func init() {
    fmt.Println("Second init")
}

func init() {
    fmt.Println("Third init")
}

func init() {
    fmt.Println("Fourth init")
}

func main() {}

لنُشغّل البرنامج كما يلي:

$ go run main.go

سيكون الخرج كما يلي:

First init
Second init
Third init
Fourth init

لاحظ أنّ تعليمات التهيئة قد نُفِّذت حسب الترتيب الذي وجدها فيه المصرِّف، وعمومًا قد لا يكون من السهل دائمًا تحديد الترتيب الذي ستُنفّذ فيه تعليمات التهيئة، ففي المثال التالي سنعرض حزمةً أكثر تعقيدًا تتضمن عدة ملفات وكل ملف لديه دالة تهيئة خاصة به. لتوضيح الأمر سننشئ برنامجًا يشارك متغيرًا اسمه message ويطبعه، والآن احذف مجلدات creature و cmd ومحتوياتهما واستبدلهما بالمجلدات وبنية الملف التالية:

├── cmd
│   ├── a.go
│   ├── b.go
│   └── main.go
└── message
    └── message.go

سنضع الآن محتويات كل ملف في a.go، لذا أضف الأسطر التالية:

package main

import (
    "fmt"

    "github.com/gopherguides/message"
)

func init() {
    fmt.Println("a ->", message.Message)
}

يتضمن الملف دالة تهيئة واحدة تطبع قيمة message.Message من الحزمة message، والآن أضف الأسطر التالية في b.go:

package main

import (
    "fmt"

    "github.com/gopherguides/message"
)

func init() {
    message.Message = "Hello"
    fmt.Println("b ->", message.Message)
}

لدينا في هذا الملف دالة تهيئة واحدة تُسند السلسلة Hello إلى المتغير message.Message وتطبعها، والآن أنشئ الآن ملف main.go كما يلي:

package main
func main() {}

هذا الملف لا يفعل شيئًا، ولكنه يوفر نقطة دخول للبرنامج لكي يُنفّذ، والآن أنشئ ملف message.go:

package message
var Message string

تُصرّح حزمة message عن المتغير المُصدّر Message، ولتشغيل البرنامج نفّذ الأمر التالي من مجلد cmd:

$ go run *.go

نحتاج إلى إخبار المصرِّف بأنه يجب تصريف جميع ملفات go. الموجودة في مجلد cmd نظرًا لوجود العديد من ملفات جو في مجلد cmd الذي يُشكّل الحزمة الرئيسية main، فمن خلال كتابة go.* يمكننا إخبار المُصرّف أنه عليه تحميل كل الملفات التي لاحقتها go. في مجلد cmd، وإذا شغّلنا الأمر go run main.go، فسيفشل البرنامج في التصريف لأنه لن يرى ملفَي a.go و b.go، وسنحصل على الخرج التالي:

a ->
b -> Hello

وفقًا لقواعد لغة جو في تهيئة الحزم، فإنه عند مصادفة عدة ملفات في الحزمة نفسها، ستكون أفضلية المعالجة وفق الترتيب الأبجدي alphabetical، لذا في أول مرة طبعنا فيها message.Message من a.go كانت القيمة المطبوعة هي القيمة الفارغة، وستبقى فارغةً طالما لم تُهيئ من خلال الدالة ()init في الملف b.go، وإذا أردنا تغيير اسم ملف a.go إلى c.go، فسنحصل على نتيجة مختلفة:

b -> Hello
a -> Hello

الآن أصبح المصّرِف يرى الملف b.go أولًا، وبالتالي أصبحت قيمة message.Message مُهيّئة بالقيمة Hello وذلك بعد تنفيذ الدالة ()init في ملف c.go.

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

يفضَّل تقديم الملفات المتعددة الموجودة ضمن الحزمة نفسها ضمن ملف واحد بترتيب مُعجمي lexical order إلى المصرِّف للتحكم بنهج التهيئة المتعدد، وبالتالي ضمان أنّ كل دوال التهيئة تُحمّل من أجل التصريح عنها في ملف واحد، وبالتالي منع تغيير ترتيب تنفيذها حتى لو تغيرت الأسماء.

يجب أن تحاول أيضًا تجنب إدارة الحالة managing state في الحزمة الخاصة بك باستخدام المتغيرات العامة، أي المتغيرات التي يمكن الوصول إليها من أيّ مكان في الحزمة، ففي البرنامج السابق مثلًا كان المتغير message.Message مُتاحًا في أيّ مكان ضمن الحزمة مع الحفاظ على حالة البرنامج، وبسبب هذه الإمكانية كانت دوال التهيئة قادرةً على الوصول إلى هذا المتغير وتعديل قيمته، وبالتالي أصبح من الصعب التنبؤ بسلوك هذا البرنامج، ولتجنب ذلك يُفضَّل إبقاء المتغيرات ضمن مساحات يمكنك التحكم بها مع إمكانية وصول ضئيلة لها قدر الإمكان حسب حاجة البرنامج.

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

استخدام دالة التهيئة لتحقيق مفهوم التأثير الجانبي

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

إحدى حالات الاستخدام الشائعة لمفهوم استيراد التأثير الجانبي هي الحصول على معلومات أولية تُفيد في تحديد أي جزء من شيفرة ما يجب أن يُنفّذ، ففي حزمة image مثلًا تحتاج الدالة image.Decode إلى معرفة تنسيق الصورة التي تحاول فك تشفيرها (jpg ،png ،gif، …إلخ) قبل أن تتمكن من تنفيذها، وهكذا أمر يمكن تحقيقه من خلال مفهوم التأثير الجانبي، فلنقل أنك تحاول استخدام image.Decode مع ملف بتنسيق png كما يلي:

. . .
func decode(reader io.Reader) image.Rectangle {
    m, _, err := image.Decode(reader)
    if err != nil {
        log.Fatal(err)
    }
    return m.Bounds()
}
. . .

هذا البرنامج سليم من ناحية التصريف، لكن إذا حاولت فك تشفير صورة بتنسيق png، فستتلقى خطأً، ولحل هذه المشكلة سنحتاج إلى تسجيل تنسيق الصورة في الدالة image.Decode، ولحسن الحظ تتضمن الحزمة image/png تعليمة التهيئة التالية:

func init() {
    image.RegisterFormat("png", pngHeader, Decode, DecodeConfig)
}

وبالتالي إذا استوردنا image/png إلى الشيفرة السابقة، فستُنفَّذ دالة التهيئة ()image.RegisterFormat مباشرةً وقبل أيّ شيء آخر.

. . .
import _ "image/png"
. . .

func decode(reader io.Reader) image.Rectangle {
    m, _, err := image.Decode(reader)
    if err != nil {
        log.Fatal(err)
    }
    return m.Bounds()
}

سيؤدي هذا إلى ضبط حالة البرنامج وتسجيل أننا نحتاج إلى إصدار png من image.Decode()‎، وسيحدث هذا التسجيل بوصفه أثرًا جانبيًا لاستيراد الحزمة image/png.

ربما لاحظت وجود الشرطة السفلية _ قبل "image/png"، فهذا أمر مهم لأنّ جو لا تسمح لك باستيراد حزمة غير مستخدَمة في البرنامج، وبالتالي فإنّ وجود الشرطة السفلية سيتجاهل أيّ شيء في الحزمة المستورَدة باستثناء تعليمة التهيئة -أي التأثير الجانبي-، وهذا يعني أنه حتى إذا لم نستورِد الحزمة image/png، فيمكننا استيراد تأثيرها الجانبي.

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

الخاتمة

تعلّمنا في هذا المقال استخدام دالة التهيئة ()init وفهمنا كيف أنها تُنفَّذ قبل أيّ شيء آخر في البرنامج وأنها تستطيع أداء بعض المهام وضبط حالة البرنامج الأولية، كما تحدّثنا أيضًا عن تعليمات التهيئة المتعددة والموجودة ضمن ملفات متعددة وكيف أنّ ترتيب تنفيذها يعتمد على على أمور محددة مثل الترتيب الأبجدي أو المعجمي لملفات الحزمة.

ترجمة -وبتصرُّف- للمقال Understanding init in Go لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: التعليمة defer في لغة جو Go
• كيفية تعريف واستدعاء الدوال في لغة جو Go

تتضمن لغة جو العديد من تعليمات التحكم بسير عمل البرنامج مثل if و switch و for …إلخ، وهذه التعليمات موجودة في أغلب لغات البرمجة، إلا أنّ هناك تعليمة خاصة في لغة جو غير موجودة في معظم اللغات الأخرى هي تعليمة التأجيل defer.

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

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

ما هي تعليمة defer؟

تسمح لك جو بتأجيل تنفيذ استدعاء دالة بإضافتها إلى طابور تنفيذ خاص ريثما تكون الدالة المُستدعاة ضمنها قد أكتمل تنفيذها من خلال استخدام الكلمة المفتاحية defer قبلها بالشكل التالي:

package main

import "fmt"

func main() {
    defer fmt.Println("Bye")
    fmt.Println("Hi")
}

أجّلنا هنا استخدام الدالة ("fmt.Println("Bye إلى حين انتهاء تنفيذ الدالة المُستدعاة ضمنها أي الدالة main، وبالتالي سيكون الخرج كما يلي:

Hi
Bye

أي سيُنفّذ هنا كل شيء داخل الدالة main ثم بعد الانتهاء من كل التعليمات (هنا لا توجد إلا تعليمة واحدة هي التعليمة التي تطبع Hi) ستُنفَّذ التعليمة المؤجلة، كما رأيت بالمثال.

والآن قد يتبادر إلى الأذهان السؤال التالي: ماذا لو كان هناك أكثر من استدعاء مؤجل، أي أكثر من دالة مؤجلة، ماذا سيحدث؟ كل دالة تُسبق بتعليمة التأجيل تُضاف إلى مكدس، ومن المعروف أنّ المكدس هو بنية معطيات تخرج منها البيانات وفق مبدأ مَن يدخل آخرًا يخرج أولًا، وبالتالي إذا كان لدينا أكثر من استدعاء مؤجل، فسيكون التنفيذ وفق هذه القاعدة، ولجعل الأمور أبسط سنأخذ المثال التالي:

package main
import "fmt"
func main() {
    defer fmt.Println("Bye1")
    defer fmt.Println("Bye2")
    fmt.Println("Hi")
}

سيكون الخرج كما يلي:

Hi
Bye2
Bye1

لدينا في البرنامج السابق استدعاءان مؤجلان، إذ يُضاف أولًا إلى المكدس التعليمة التي تطبع Bye1 ثم التعليمة التي تطبع Bye2، ووفق القاعدة السابقة ستُطبع التعليمة التي أٌضيفت أخيرًا إلى المكدس أي Bye2 ثم Bye1، وبالطبع تُنفَّذ التعليمة التي تطبع Hi وأيّ تعليمة أخرى ضمن الدالة main قبل تنفيذ أيّ تعليمة مؤجلة، ولدينا مثال آخر كما يلي:

package main

import "fmt"

func main() {
    fmt.Println("Hi0")
    defer fmt.Println("Bye1")
    defer fmt.Println("Bye2")
    fmt.Println("Hi1")
    fmt.Println("Hi2")
}

سيكون الخرج كما يلي:

Hi0
Hi1
Hi2
Bye2
Bye1

عند تأجيل تنفيذ دالة ما ستقيَّم الوسائط على الفور، وبالتالي لن يؤثر أيّ تعديل لاحق، لذا انتبه جيدًا إلى المثال التالي:

package main

import "fmt"

func main() {
    x := 9
    defer fmt.Println(x)
    x = 10
}

سيكون الخرج كما يلي:

9

كانت هنا قيمة x تساوي 9 ثم أجلنا تنفيذ دالة الطباعة التي تطبع قيمة هذا المتغير، وعلى الرغم من أنّ تعليمة x=10 ستُنفَّذ قبل تعليمة الطباعة، إلا أنّ القيمة التي طُبعَت هي القيمة السابقة للمتغير x وذلك للسبب الذي ذكرناه منذ قليل.

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

تنظيف الموارد باستخدام تعليمة التأجيل

يُعَدّ استخدام تعليمة التأجيل لتنظيف الموارد أمرًا شائعًا جدًا في جو، وسنلقي الآن نظرةً على برنامج يكتب سلسلةً نصيةً في ملف ولكنه لا يستخدِم تعليمة التأجيل لتنظيف المورد:

package main

import (
    "io"
    "log"
    "os"
)

func main() {
    if err := write("readme.txt", "This is a readme file"); err != nil {
        log.Fatal("failed to write file:", err)
    }
}

func write(fileName string, text string) error {
    file, err := os.Create(fileName)
    if err != nil {
        return err
    }
    _, err = io.WriteString(file, text)
    if err != nil {
        return err
    }
    file.Close()
    return nil
}

لدينا في هذا البرنامج دالة تسمى write والهدف منها بدايةً هو محاولة إنشاء ملف، وإذا حصل خطأ أثناء هذه المحاولة، فستُعيد هذا الخطأ وتُنهي التنفيذ؛ أما في حال نجاح عملية إنشاء الملف، فستكتب فيه السلسلة This is a readme file، وفي حال فشلت عملية الكتابة، فستُعيد الخطأ وتنهي تنفيذ الدالة أيضًا، وأخيرًا إذا نجح كل شيء، فستغلق الدالة الملف الذي أُنشِئ معيدة إياه إلى نظام الملفات ثم تُعيد القيمة nil إشارةً إلى نجاح التنفيذ.

هذا البرنامج يعمل بطريقة سليمة، إلا أنّ هناك زلة برمجية صغيرة؛ فإذا فشلت عملية الكتابة في الملف، فسيبقى الملف المُنشئ مفتوحًا، أي توجد هناك موارد غير محررة، ولحل هذه المشكلة مبدأيًا يمكنك تعليمة file.Close()‎ أخرى ومن دون استخدام تعليمة التأجيل:

package main

import (
    "io"
    "log"
    "os"
)

func main() {
    if err := write("readme.txt", "This is a readme file"); err != nil {
        log.Fatal("failed to write file:", err)
    }
}

func write(fileName string, text string) error {
    file, err := os.Create(fileName)
    if err != nil {
        return err
    }
    _, err = io.WriteString(file, text)
    if err != nil {
        file.Close()
        return err
    }
    file.Close()
    return nil
}

الآن سيُغلق الملف حتى إذا فشل تنفيذ io.WriteString، وقد يكون هذا حلًا بسيطًا وأسهل من غيره، لكن إذا كانت الدوال أكثر تعقيدًا، فقد ننسى إضافة هكذا تعليمات في الأماكن المُحتملة التي قد ينتهي فيها التنفيذ قبل تحرير المورد، لذا يتمثّل الحال الأكثر احترافيةً وأمانًا باستخدام تعليمة التأجيل مع الدالة file.Close وبالتالي ضمان تنفيذها دومًا بغض النظر عن أيّ مسار تنفيذ أو خطأ مُفاجئ قد يؤدي إلى إنهاء الدالة:

package main

import (
    "io"
    "log"
    "os"
)

func main() {
    if err := write("readme.txt", "This is a readme file"); err != nil {
        log.Fatal("failed to write file:", err)
    }
}

func write(fileName string, text string) error {
    file, err := os.Create(fileName)
    if err != nil {
        return err
    }
    defer file.Close()
    _, err = io.WriteString(file, text)
    if err != nil {
        return err
    }
    return nil
}

أضفنا هنا السطر defer file.Close لإخبار المُصرّف بإغلاق الملف بعد انتهاء تنفيذ الدالة، وبالتالي ضمان تحريره مهما حدث.

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

يُعَدّ استدعاء الدالة Close في جو أكثر من مرة آمنًا ولا يؤثر على سلوك البرنامج، وفي حال كان هناك خطأ، فسيُعاد من المرة الأولى التي تُستدعى فيها الدالة، وبالتالي سيسمح لنا هذا باستدعائها ضمن مسار التنفيذ الناجح في الدالة.

سنعالج في المثال التالي المشكلة السابقة التي تتجلى بعدم إمكانية الحصول على معلومات الخطأ في حال حدوثه مع تعليمة الإغلاق المؤجلة:

package main

import (
    "io"
    "log"
    "os"
)

func main() {
    if err := write("readme.txt", "This is a readme file"); err != nil {
        log.Fatal("failed to write file:", err)
    }
}

func write(fileName string, text string) error {
    file, err := os.Create(fileName)
    if err != nil {
        return err
    }
    defer file.Close()
    _, err = io.WriteString(file, text)
    if err != nil {
        return err
    }

    return file.Close()
}

لاحظ أنّ التعديل الوحيد على الشيفرة السابقة كان بإضافة السطر return file.Close()‎، وبالتالي إذا حصل خطأ في عملية الإغلاق، فسيُعاد مباشرةً إلى الدالة التي تستدعي الدالة write، ولاحظ أيضًا أنّ التعليمة defer file.Close ستُنفّذ بكافة الأحوال، مما يعني أنّ تعليمة الإغلاق ستُنفّذ مرتين غالبًا، وعلى الرغم من أنّ ذلك ليس مثاليًّا، إلا أنه مقبول وآمن.

إذا ظهر خطأ في تعليمة WriteString، فسيُعاد الخطأ وينتهي تنفيذ الدالة ثم ستُنفّذ تعليمة file.Close لأنها تعليمة مؤجلة، وهنا على الرغم من إمكانية ظهور خطأ عند محاولة إغلاق الملف، إلا أنّ هذا الخطأ لم يَعُد مهمًا لأن الخطأ الذي تعيده WriteString سيكون غالبًا هو السبب وراء حدوثه.

تعرّفنا حتى الآن على كيفية استخدام تعليمة التأجيل واحدة لضمان تحرير أو تنظيف مورد ما، وسنتعلّم الآن كيفية استخدام عدة تعليمات تأجيل من أجل تنظيف أكثر من مورد.

استخدام تعليمات تأجيل متعددة

من الطبيعي أن تكون لديك أكثر من تعليمة defer في دالة ما، لذا دعنا ننشئ برنامجًا يحتوي على تعليمات تأجيل فقط لنرى ما سيحدث في هذه الحالة (كما أشرنا سابقًا):

package main

import "fmt"

func main() {
    defer fmt.Println("one")
    defer fmt.Println("two")
    defer fmt.Println("three")
}

سيكون الخرج كما يلي:

three
two
one

كما ذكرنا سابقًا أنّ سبب الطباعة بهذا الترتيب هو أن تعليمة التأجيل تعتمد على تخزين سلسلة الاستدعاءات ضمن بنية المكدس، والمهم الآن أن تعرف أنه يمكن أن يكون لديك العديد من الاستدعاءات المؤجلة حسب الحاجة في دالة ما، ومن المهم أن تتذكر أنها تُستدعى جميعها بعكس ترتيبها في الشيفرة حسب بنية المكدس.

الآن بعد أن فهمنا هذه الفكرة جيدًا، سننشئ برنامجًا يفتح ملفًا ويكتب عليه ثم يفتحه مرةً أخرى لنسخ المحتويات إلى ملف آخر:

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

func main() {
    if err := write("sample.txt", "This file contains some sample text."); err != nil {
        log.Fatal("failed to create file")
    }

    if err := fileCopy("sample.txt", "sample-copy.txt"); err != nil {
        log.Fatal("failed to copy file: %s")
    }
}

func write(fileName string, text string) error {
    file, err := os.Create(fileName)
    if err != nil {
        return err
    }
    defer file.Close()
    _, err = io.WriteString(file, text)
    if err != nil {
        return err
    }

    return file.Close()
}

func fileCopy(source string, destination string) error {
    src, err := os.Open(source)
    if err != nil {
        return err
    }
    defer src.Close()

    dst, err := os.Create(destination)
    if err != nil {
        return err
    }
    defer dst.Close()

    n, err := io.Copy(dst, src)
    if err != nil {
        return err
    }
    fmt.Printf("Copied %d bytes from %s to %s\n", n, source, destination)

    if err := src.Close(); err != nil {
        return err
    }

    return dst.Close()
}

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

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

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

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

الخاتمة

تحدثنا في هذا المقال عن تعليمة التأجيل defer وكيفية استخدامها والتعامل معها وأهميتها في تنظيف وتحرير الموارد بعد الانتهاء من استخدامها، وبالتالي ضمان توفير الموارد للمستخدِمين المختلفِين وتوفير الذاكرة.

يمكنك أيضًا الرجوع إلى مقال معالجة حالات الانهيار في لغة جو Go: يتضمن حالةً خاصةً من حالات استخدام تعليمة التأجيل.

ترجمة -وبتصرُّف- للمقال Understanding defer in Go لصاحبه Gopher Guides.

اقرأ أيضا

• المقال السابق: كيفية تعريف واستدعاء الدوال في لغة جو Go
• كيفية كتابة التعليمات الشرطية if في لغة جو Go
• فهم الملفات Files وأنظمة الملفات file systems

تُعَدّ الدالة funtion كتلةً من التعليمات التي تنفِّذ إجراءً ما، ويمكن بعد تعريفها إعادة استخدامها في أكثر من موضع. تجعل الدوال الشيفرة تركيبية modular، مما يسمح بتقسيم الشيفرة إلى أجزاء صغيرة سهلة الفهم واستخدامها مرارًا وتكرارًا. تضم لغة جو مكتبةً قياسيةً تدعى fmt، إذ تحتوي على عدد من الدوال المُضمّنة التي قد تكون شائعة بالنسبة لك مثل:

• الدالة ()fmt.Println تُستخدَم للطباعة على شاشة الخرج القياسية المُستخدَمة.
• الدالة ()fmt.Printf تُستخدَم للطباعة مع إمكانية تنسيق الخرج.

تتضمن أسماء الدوال الأقواس وقد تتضمن معامِلات أيضًا، وسنتعلم في هذا المقال كيفية تعريف الدوال وكيفية استخدامها في البرامج.

تعريف الدالة

لنبدأ بتحويل برنامج "Hello, World!‎" إلى دالة، لذا أنشئ ملفًا نصيًا جديدًا وافتحه في محرر النصوص المفضل عندك ثم استدع البرنامج ‎hello.go.

تُعرَّف الدالة باستخدام الكلمة المفتاحية func متبوعة باسم من اختيارك ثم قوسين يمكن أن يَحتويا المعامِلات التي ستأخذها الدالة ثم ينتهي التعريف بنقطتين، وسنعرّف هنا دالةً باسم ‎‎hello()‎‎:

func hello() {}

أعددنا في الشفرة أعلاه تعليمة التهيئة لإنشاء الدالة، وبعد ذلك سنضيف سطرًا ثانيًا مُزاحًا بأربع مسافات بيضاء ثم سنكتب التعليمات التي ستنفّذها الدالة، وفي هذه الحالة سنطبع العبارة !Hello, World في الطرفية:

func hello() {
    fmt.Println("Hello, World!")
}

أتممنا تعريف دالتنا ولكن إذا نَفَّذنا البرنامج الآن، فلن يحدث أيّ شيء لأننا لم نستدع الدالة، لذلك سنستدعي الدالة ‎hello()‎ ضمن الدالة ()main كما يلي:

package main

import "fmt"

func main() {
    hello()
}

func hello() {
    fmt.Println("Hello, World!")
}

لننفّذ البرنامج الآن كما يلي:

$ go run hello.go

يجب أن تحصل على الخرج التالي:

Hello, World!

الدالة ()main هي دالة خاصة تخبر المُصرّف أنّ هذا هو المكان الذي يجب أن يبدأ منه البرنامج، فأيّ برنامج تريده أن يكون قابلاً للتنفيذ (برنامج يمكن تشغيله من الطرفية)، فستحتاج إلى دالة ()main، كما يجب أن تظهر الدالة ()main مرةً واحدةً فقط وأن تكون في الحزمة main ولا تستقبل أو تعيد أيّ وسائط، وهذا يسمح بتنفيذ البرنامج في أيّ برنامج جو آخر حسب المثال التالي:

package main

import "fmt"

func main() {
    fmt.Println("this is the main section of the program")
}

بعض الدوال أكثر تعقيدًا بكثير من الدالة ‎hello()‎ التي عرّفناها أعلاه، إذ يمكننا على سبيل المثال استخدام حلقة for والتعليمات الشرطية وغيرها داخل كتلة الدالة، فالدالة المُعرّفة أدناه على سبيل المثال تستخدِم تعليمةً شرطيةً للتحقق مما إذا كانت المدخلات الممرّرة إلى المتغير ‎name‎ تحتوي على حرف صوتي vowel، ثم تستخدِم الحلقة ‎for‎ للتكرار على الحروف الموجودة في السلسلة النصية ‎name‎.

package main

import (
    "fmt"
    "strings"
)

func main() {
    names()
}

func names() {
    fmt.Println("Enter your name:")

    var name string
    fmt.Scanln(&name)
    // Check whether name has a vowel
    for _, v := range strings.ToLower(name) {
        if v == 'a' || v == 'e' || v == 'i' || v == 'o' || v == 'u' {
            fmt.Println("Your name contains a vowel.")
            return
        }
    }
    fmt.Println("Your name does not contain a vowel.")
}

تستخدِم الدالة ‎names()‎ التي عرّفناها أعلاه تعليمةً شرطيةً وحلقة ‎for‎، وهذا توضيح لكيفية تنظيم الشيفرة البرمجية ضمن تعريف الدالة، كما يمكننا أيضًا جعل التعليمة الشرطية والحلقة ‎for‎ دالتين منفصلتين. يجعل تعريف الدوال داخل البرامج الشفرة البرمجية تركيبيةً modular وقابلةً لإعادة الاستخدام، وذلك سيتيح لنا استدعاء الدالة نفسها دون إعادة كتابة شيفرتها في كل مرة.

المعاملات

عرّفنا حتى الآن دالة ذات قوسين فارغين لا تأخذ أيّ وسائط arguments، وسنتعلم في هذا القسم كيفية تعريف المعامِلات parameters وتمرير البيانات إلى الدوال.

يُعَدّ المعامِل كيانًا مُسمًّى يوضَع في تعريف الدالة ويعرِّف وسيطًا يمكن أن تقبله الدالة عند استدعائها، ويجب عليك في لغة Go أن تحدد نوع البيانات data type لكل معامِل

لننشئ برنامجًا يُكرر كلمة عدة مرات، إذ سنحتاج إلى متغير من النوع string سنسميه word ومتغير من النوع int سنسميه reps يُحدد عدد التكرارات.

package main

import "fmt"

func main() {
    repeat("Sammy", 5)
}

func repeat(word string, reps int) {
    for i := 0; i < reps; i++ {
        fmt.Print(word)
    }
}

مرّرنا السلسلة Sammy إلى المتغير word والقيمة 5 إلى المعامِل reps وذلك وفقًا لترتيب المعامِلات في ترويسة الدالة repeat، إذ تتضمّن الدالة حلقة for تطبع قيمة المعامِل word عدة مرات يُحدّدها المعامِل reps، وسيكون الخرج كما يلي:

SammySammySammySammySammy

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

package main

import "fmt"

func main() {
    addNumbers(1, 2, 3)
}

func addNumbers(x, y, z int) {
    a := x + y
    b := x + z
    c := y + z
    fmt.Println(a, b, c)
}

عند تعريف الدالة addNumbers لم نكن بحاجة إلى تحديد نوع كل متغير على حدة، وإنما وضعنا نوع بيانات كل المتغيرات مرةً واحدةً فقط.

مرّرنا العدد ‎1‎ إلى المعامل ‎x‎ والعدد ‎2‎ إلى المعامل ‎y‎ والعدد ‎3‎ إلى المعامل ‎z‎، إذ تتوافق هذه القيم مع المعامِلات المقابلة لها في ترتيب الظهور، ويُجري البرنامج العمليات الحسابية على المعامِلات على النحو التالي:

a = 1 + 2
b = 1 + 3
c = 2 + 3

تطبع الدالة أيضًا ‎a‎ و ‎b‎ و ‎c‎، وبناءً على العمليات الحسابية أعلاه، فستساوي قيمة ‎a‎ العدد ‎3‎ و ‎b‎ العدد ‎4‎ و ‎c‎ العدد ‎5‎، ولننفّذ البرنامج سنكتب ما يلي:

$ go run add_numbers.go

سيكون الخرج كما يلي:

3 4 5

عندما نمرر 1 و 2 و 3 على أساس معامِلات إلى الدالة ()addNumbers، فإننا نتلقى الناتج المتوقع.

تُعَدّ المعامِلات وسائط تُعرَّف عادة على أساس متغيرات ضمن تعريف الدالة، كما يمكن تعيين قيم إليها عند تنفيذ التابع بتمرير وسائط إلى الدالة.

إعادة قيمة

يمكن تمرير قيم إلى الدالة ويمكن كذلك أن تُنتج الدالة قيمةً وتُعيدها لمن استدعاها، إذ يمكن أن تنتج الدالة قيمةً عبر استخدام التعليمة ‎return‎ وهي تعليمة اختيارية، ولكن في حال استخدامها ستُنهي الدالة عملها مباشرةً وتوقف تنفيذها وتُمرَّر قيمة التعبير الذي يعقُبها اختياريًا إلى المستدعي، كما يجب تحديد نوع البيانات المُعادة أيضًا.

استخدمنا حتى الآن الدالة ()fmt.Println‎ بدلاً من التعليمة ‎return‎ في دوالنا لطباعة شيء بدلًا من إعادته، فلننشئ برنامجًا يعيد متغيرًا بدلًا من طباعته مباشرةً، لذا سننشئ برنامجًا في ملف نصي جديد يسمى double.go‎ يحسب ناتج مُضاعفة المعامِل ‎x‎ ويُسند الناتج إلى المتغير ‎y‎ ثم يعيده، كما سنطبع المتغير ‎result‎ والذي يساوي ناتج تنفيذ الدالة double(3)‎.

package main

import "fmt"

func main() {
    result := double(3)
    fmt.Println(result)
}

func double(x int) int {
    y := x * 2
    return y
}

لننفّذ البرنامج كما يلي:

$ go run double.go

سيكون الخرج كما يلي:

6

خرج البرنامج هو العدد الصحيح ‎6 الذي أعادته الدالة وهو ما نتوقعه إذا طلبنا من جو حساب ناتج ضرب 2 بالعدد 3.

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

package main

import "fmt"

func main() {
    result := double(3)
    fmt.Println(result)
}

func double(x int) int {
    y := x * 2
    // return y
}

لنحاول تنفيذ البرنامج:

$ go run double.go

سيُشير الخرج إلى خطأ لأنه لم يجد تعليمة الإعادة return:

./double.go:13:1: missing return at end of function

لا يمكن تصريف البرنامج بدون تعليمة الإعادة هذه، فعندما تصل الدالة إلى تعليمة return فإنها ستُنهي تنفيذ الدالة حتى إذا كان هناك تعليمات تالية ضمنها:

package main

import "fmt"

func main() {
    loopFive()
}

func loopFive() {
    for i := 0; i < 25; i++ {
        fmt.Print(i)
        if i == 5 {
            //i == 5 أوقف الدالة عندما 
          return
        }
    }
    fmt.Println("This line will not execute.") // هذا السطر لن ينفَّذ
}

نستخدِم هنا حلقة for تُؤدي عملية تكرار 25 مرة وبداخلها تعليمة if تتحقق مما إذا كانت قيمة i تساوي العدد 5، فإذا كانت كذلك، فسيكون لدينا تعليمة return تُنهي تنفيذ الحلقة وتُنهي تنفيذ الدالة أيضًا، وهذا يعني أنّ باقي التكرارات لن تُنفّذ والسطر الأخير من الدالة This line will not execute لن يُنفّذ.

يؤدي استخدام التعليمة ‎return‎ داخل الحلقة ‎for‎ إلى إنهاء الدالة، وبالتالي لن يُنفَّذ السطر الموجود خارج الحلقة، فإذا استخدمنا بدلًا من ذلك التعليمة break، فسيُنفّذ السطر fmt.Println()‎ الأخير من المثال السابق.

نعيد التذكير أنَّ التعليمة ‎return‎ تنهي عمل الدالة وقد تعيد قيمةً إذا أعقبها تعبير وكان ذلك محدد في تعريف الدالة.

إعادة عدة قيم

يمكن للدوال أن تُعيد أكثر من قيمة، إذ سنجعل برنامج repeat.go يُعيد قيمتين بحيث تكون القيمة الأولى القيمة المُكررة والثانية خطأً في حال كانت قيمة المعامِل reps أصغر أو تساوي 0.

package main

import "fmt"

func main() {
    val, err := repeat("Sammy", -1)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(val)
}

func repeat(word string, reps int) (string, error) {
    if reps <= 0 {
        return "", fmt.Errorf("invalid value of %d provided for reps. value must be greater than 0.", reps)
    }
    var value string
    for i := 0; i < reps; i++ {
        value = value + word
    }
    return value, nil
}

تتحقق الدالة repeat بدايةً من أن الوسيط reps صالح، فأيّ قيمة أقل أو تساوي الصفر ستؤدي إلى خطأ. بما أننا مررنا القيمة 1- إلى reps فهذا سيؤدي إلى تحقق شرط حدوث خطأ، وبالتالي ستُعاد قيمتين الأولى هي سلسلة فارغة "" والثانية هي رسالة خطأ، وبالطبع يجب علينا إعادة قيمتين دومًا تبعًا للتعريف الذي وضعناه في ترويسة الدالة، إذ حددنا أنّ هناك قيمتان مُعادتان من الدالة؛ فالأولى هي سلسلة والثانية هي خطأ، ولهذا السبب أعدنا سلسلةً فارغةً في حال ظهور خطأ.

نستدعي الدالة repeat بداخل الدالة main ونُسند القيم المُعادة إلى متغيرين هما value و err، وبما أنّ هناك احتمال لحدوث خطأ، فسنتحقق في الأسطر التالية من وجوده، وفي حال وجوده سنطبع رسالةً تشير إلى الخطأ وسنستخدِم التعليمة return للخروج من الدالة main والبرنامج، وبتنفيذ البرنامج سنحصل على ما يلي:

invalid value of -1 provided for reps. value must be greater than 0.

ملاحظة: من السلوكيات الجيدة في البرمجة إعادة قيمتان أو ثلاثة، بالإضافة إلى إعادة كل الأخطاء كآخر قيمة معادة من الدالة. تعلّمنا في هذا القسم كيف نجعل تعليمة return تُعيد أكثر من قيمة.

الدوال المرنة Variadic

الدالة المرنة Variadic هي دالة لا تقبل أي قيمة أو تقبل قيمةً واحدةً أو قيمتين أو أكثر على أساس وسيط واحد، والدوال المرنة ليست شائعة الاستخدام لكنها تجعل الشيفرة أنظف وأكثر قابليةً للقراءة، وأحد الأمثلة على هذا النوع من الدوال هو الدالة Println من الحزمة fmt:

func Println(a ...interface{}) (n int, err error)

نسمي الدالة التي تتضمن مُعامِلًا مُلحقًا بثلاثة نقاط ... كما في الشيفرة أعلاه بالدالة المرنة، إذ تشير النقاط الثلاث إلى أنّ هذا المعامِل يمكن أن يكون صفر قيمة أو قيمةً واحدةً أو قيمتين أو عدة قيم، وبالتالي تُعَدّ الدالة fmt.Println دالةً مرنةً لأنها تتضمن مُعامِلًا مرنًا يسمى a.

سنستخدِم في المثال التالي الدالة المرنة السابقة وسنبيّن كيف أنه من الممكن أن نمرر لها عددًا غير مُحدد من الوسائط:

package main

import "fmt"

func main() {
    fmt.Println()
    fmt.Println("one")
    fmt.Println("one", "two")
    fmt.Println("one", "two", "three")
}

كما تُلاحظ فإننا نستدعيها أول مرة بدون تمرير أيّ وسيط ثم نستدعيها مع تمرير وسيط واحد هو السلسلة one ثم نستدعيها مع وسيطين ثم نستدعيها مع ثلاثة وسائط، ولننفذ البرنامج الآن:

$ go run print.go

سيكون الخرج كما يلي:

one
one two
one two three

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

سنتحدّث الآن عن كيفية تعريف هذه الدوال بعد أن اطلعنا على كيفية استخدام الدوال المرنة.

تعريف الدوال المرنة

كما ذكرنا سابقًا فإن الدوال المرنة تُعرّف من خلال وضع ثلاث نقاط ... بعد اسم أحد المعامِلات فيها، وفي المثال التالي سنعرّف دالةً نمرر لها أسماءً لكي تُحَييهم:

package main

import "fmt"

func main() {
    sayHello()
    sayHello("Sammy")
    sayHello("Sammy", "Jessica", "Drew", "Jamie")
}

func sayHello(names ...string) {
    for _, n := range names {
        fmt.Printf("Hello %s\n", n)
    }
}

تتضمّن الدالة sayHello معامِلًا اسمه names من النوع string، وكما نلاحظ فإنه توجد ثلاث نقاط بعد اسمه، وبالتالي هو معامل مرن أي يقبل عدد غير مُحدد من الوسائط، وبالتالي تُعَدّ الدالة sayHello هي دالةً مرنةً.

تُعامِل هذه الدالة المعامِل names على أنه شريحة من الأسماء، أي أنها تعامله على أساس شريحة من السلاسل النصية string[]، وبالتالي يمكننا التكرار عليه بحلقة for من خلال استخدام العامِل range.

ستحصل عند تنفيذ هذه الشيفرة على ما يلي:

Hello Sammy
Hello Sammy
Hello Jessica
Hello Drew
Hello Jamie

لاحظ أنه في المرة الأولى التي استدعينا فيها الدالة sayHello لم يُطبع أيّ شيء، وذلك لأننا لم نمرر لها أيّ قيمة، أي عمليًّا هي شريحة فارغة، وبالتالي لا تتضمن أي قيمة ليُكرر عليها، والآن سنُعدّل الشيفرة السابقة بحيث تطبع عبارةً مُحددةً عندما لا تُمرّر أيّ قيمة:

package main

import "fmt"

func main() {
    sayHello()
    sayHello("Sammy")
    sayHello("Sammy", "Jessica", "Drew", "Jamie")
}

func sayHello(names ...string) {
    if len(names) == 0 {
        fmt.Println("nobody to greet")
        return
    }
    for _, n := range names {
        fmt.Printf("Hello %s\n", n)
    }
}

أضفنا تعليمة if تتحقق مما إذا كانت الشريحة فارغةً وهذا يُكافئ أن يكون طولها 0، وفي هذه الحالة سنطبع nobody to greet:

nobody to greet
Hello Sammy
Hello Sammy
Hello Jessica
Hello Drew
Hello Jamie

يجعل استخدام الدوال والمتغيرات المرنة شيفرتك أكثر قابليةً للقراءة، وسنُنشئ الآن دالةً مرنةً تربط الكلمات اعتمادًا على رمز مُحدّد، لكن سنكتب أولًا دالةً ليست مرنة لنُبيّن الفرق:

package main

import "fmt"

func main() {
    var line string

    line = join(",", []string{"Sammy", "Jessica", "Drew", "Jamie"})
    fmt.Println(line)

    line = join(",", []string{"Sammy", "Jessica"})
    fmt.Println(line)

    line = join(",", []string{"Sammy"})
    fmt.Println(line)
}

func join(del string, values []string) string {
    var line string
    for i, v := range values {
        line = line + v
        if i != len(values)-1 {
            line = line + del
        }
    }
    return line
}

مرّرنا هنا الفاصلة , إلى الدالة join لكي يُنجز الربط اعتمادًا عليها، ثم مرّرنا شريحةً من الكلمات لكي تُربط، فكان الخرج كما يلي:

Sammy,Jessica,Drew,Jamie
Sammy,Jessica
Sammy

لاحظ هنا أنّ تعريف شريحة في كل مرة نستدعي فيها هذه الدالة قد يكون مُملًا وأكثر صعوبةً في القراءة، لذا سنُعرّف الآن الشيفرة نفسها لكن مع دالة مرنة:

package main

import "fmt"

func main() {
    var line string

    line = join(",", "Sammy", "Jessica", "Drew", "Jamie")
    fmt.Println(line)

    line = join(",", "Sammy", "Jessica")
    fmt.Println(line)

    line = join(",", "Sammy")
    fmt.Println(line)
}

func join(del string, values ...string) string {
    var line string
    for i, v := range values {
        line = line + v
        if i != len(values)-1 {
            line = line + del
        }
    }
    return line
}

سنحصل عند تشغيل البرنامج على خرج المثال السابق نفسه:

Sammy,Jessica,Drew,Jamie
Sammy,Jessica
Sammy

يمكن بسهولة ملاحظة أنّ استخدام مفهوم الدالة المرنة قد جعل من الدالة join أكثر قابليةً للقراءة.

ترتيب الوسائط المرنة

يمكنك تعريف معامِل مرن واحدة فقط في الدالة ويجب أن يكون هو المعامِل الأخير في ترويسة الدالة، فإذا عرّفتَ أكثر من معامِل مرن أو وضعته قبل المعامِلات العادية، فسيظهر لك خطأ وقت التصريف compilation error.

package main

import "fmt"

func main() {
    var line string

    line = join(",", "Sammy", "Jessica", "Drew", "Jamie")
    fmt.Println(line)

    line = join(",", "Sammy", "Jessica")
    fmt.Println(line)

    line = join(",", "Sammy")
    fmt.Println(line)
}

func join(values ...string, del string) string {
    var line string
    for i, v := range values {
        line = line + v
        if i != len(values)-1 {
            line = line + del
        }
    }
    return line
}

وضعنا هنا المعامِل المرن values أولًا ثم وضعنا المعامِل العادي del، وبالتالي خالفنا الشرط المذكور سلفًا، وبالتالي سنحصل على الخطأ التالي:

./join_error.go:18:11: syntax error: cannot use ... with non-final parameter values

عند تعريف دالة مرنة لا يمكن أن يكون المعامِل الأخير إلا معاملًا مرنًا.

تفكيك الوسائط

رأينا كيف أنّ المعامل المرن سيسمح لنا بتمرير 0 قيمة أو قيمة واحدة أو أكثر من قيمة إلى الدالة، لكن هناك حالات سيكون لدينا فيها شريحة من القيم نريد تمريرها إلى الدالة المرنة، لذا دعونا نرى الدالة join التي بنيناها مؤخرًا لرؤية ما يحدث:

package main

import "fmt"

func main() {
    var line string

    names := []string{"Sammy", "Jessica", "Drew", "Jamie"}

    line = join(",", names)
    fmt.Println(line)
}

func join(del string, values ...string) string {
    var line string
    for i, v := range values {
        line = line + v
        if i != len(values)-1 {
            line = line + del
        }
    }
    return line
}

سنحصل عند تشغيل البرنامج على خطأ وقت التصريف:

./join-error.go:10:14: cannot use names (type []string) as type string in argument to join

على الرغم من أن الدالة المرنة ستحوّل المعامِل values ...string إلى شريحة من السلاسل النصية string[]، إلا أنّ هذا لا يعني أنه بإمكاننا تمرير شريحة من السلاسل على أساس وسيط، فالمُصرّف يتوقع وسائط منفصلةً من نوع سلسلة نصية.

يمكننا لحل هذه المشكلة تفكيك قيم الشريحة -أي فصلها عمليًّا- من خلال وضع ثلاثة نقط بعد اسم الشريحة عندما نُمررها لدالة مرنة.

package main

import "fmt"

func main() {
    var line string

    names := []string{"Sammy", "Jessica", "Drew", "Jamie"}

    line = join(",", names...)
    fmt.Println(line)
}

func join(del string, values ...string) string {
    var line string
    for i, v := range values {
        line = line + v
        if i != len(values)-1 {
            line = line + del
        }
    }
    return line
}

لاحظ أننا وضعنا 3 نقاط بعد اسم الشريحة names عندما مررناها إلى الدالة join، وهذا يؤدي إلى تفكيك عناصر الشريحة، وبالتالي كأنها قيم منفصلة، وسيكون الخرج كما يلي:

Sammy,Jessica,Drew,Jamie

لاحظ أنه مازال بإمكاننا عدم تمرير أيّ شيء أو تمرير أيّ عدد نريده من القيم، ويبيّن المثال التالي كل الحالات:

package main

import "fmt"

func main() {
    var line string

    line = join(",", []string{"Sammy", "Jessica", "Drew", "Jamie"}...)
    fmt.Println(line)

    line = join(",", "Sammy", "Jessica", "Drew", "Jamie")
    fmt.Println(line)

    line = join(",", "Sammy", "Jessica")
    fmt.Println(line)

    line = join(",", "Sammy")
    fmt.Println(line)

}

func join(del string, values ...string) string {
    var line string
    for i, v := range values {
        line = line + v
        if i != len(values)-1 {
            line = line + del
        }
    }
    return line
}

سيكون الخرج كما يلي:

Sammy,Jessica,Drew,Jamie
Sammy,Jessica,Drew,Jamie
Sammy,Jessica
Sammy

أصبحنا الآن نعرف كيف نمرِّر 0 قيمة أو أكثر إلى دالة مرنة، كما أصبحنا نعرف كيف يمكننا تمرير شريحة إلى دالة مرنة.

غالبًا ما تكون الدوال المرنة مفيدةً في الحالات التالية:

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

الخاتمة

تُعَدّ الدوال كتلًا من التعليمات البرمجية التي تُنفِّذ إجراءات معيّنة داخل البرنامج، كما تساعد على جعل الشفرة تركيبيةً وقابلةً لإعادة الاستخدام، بالإضافة إلى أنها تنظمها وتسهل من قراءتها، كما تجعل الدوال المرنة الشيفرة أكثر قابليةً للقراءة، إلا أنها ليست شائعة الاستخدام، ولتتعلم كيف تجعل برنامجك تركيبيًّا أكثر، فيمكنك قراءة مقال كيفية تعريف الحزم في لغة جو Go.

ترجمة -وبتصرف- للمقالَين How To Define and Call Functions in Go وللمقال How To Use Variadic Functions in Go لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: التعامل مع حلقة التكرار For في لغة جو Go
• استخدام المتغيرات والثوابت في لغة جو Go

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

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

تؤدي حلقة for إلى تكرار تنفيذ جزء من الشيفرات بناءً على عدّاد أو على متغير، وهذا يعني أنّ حلقات for تستعمل عندما يكون عدد مرات تنفيذ حلقة التكرار معلومًا قبل الدخول في الحلقة، لكن في حقيقة الأمر يمكنك استخدامها حتى إذا لم يكن عدد التكرارات معلومًا من خلال استخدام تعليمة break كما سترى لاحقًا.

سنبدأ بالحديث في هذا المقال عن الأنواع المختلفة من هذه الحلقة ثم كيفية التكرار على أنواع البيانات التسلسلية مثل البيانات النصية Strings ثم الحلقات المتداخلة.

التصريح عن حلقة For

حددت لغة جو 3 طرق مختلفة لإنشاء الحلقات كُلٌّ منها بخصائص مختلفة بوضع كل حالات الاستخدام الممكنة للحلقات في الحسبان، وهي إنشاء حلقة for مع شرط Condition أو ForClause أو RangeClause، إذ سنشرح في هذا القسم كيفية تصريح واستخدام أنواع ForClause و Condition، لذا دعونا نلقي نظرةً على كيفية استخدام حلقة for مع ForClause أولًا.

تُعرّف حلقة ForClause من خلال كتابة تعليمة التهيئة initial statement متبوعة بشرط Condition متبوعة بتعليمة التقدّم Post Statement:

for [ Initial Statement ] ; [ Condition ] ; [ Post Statement ] {
    [Action]
}

لكي نفهم المكونات السابق سنرى المثال التالي الذي يعرض حلقة for تتزايد ضمن نطاق محدد من القيم باستخدام التعريف السابق:

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

يتمثل الجزء الأول من الحلقة في تعليمة التهيئة i := 0 والتي تعبر عن تصريح متغير اسمه i يُسمى متغير الحلقة وقيمته الأولية هي 0؛ أما الجزء الثاني فهو الشرط i < 5 والذي يُمثّل الشرط الذي يجب أن يتحقق لكي ندخل في الحلقة أو في التكرار التالي من الحلقة، إذ يمكن القول ادخُل في الحلقة ونفّذ محتواها طالما أنّ قيمة i أصغر من 5، والجزء الأخير هو تعليمة التقدّم ++i والتي تشير إلى التعديل الذي سنجريه على متغير الحلقة i بعد انتهاء كل تكرار، إذ يكون التعديل هنا هو زيادته بمقدار واحد.

سيكون خرج البرنامج كما يلي:

0
1
2
3
4

تتكرر الحلقة 5 مرات، بدايةً تكون قيمة i تساوي 0 وهي أصغر من 5، لذا ندخل في الحلقة وننفّذ محتواها (fmt.Println(i ثم نزيد قيمة متغير الحلقة بواحد فتصبح قيمته 1 وهي أصغر من 5، ثم ننفّذ محتوى الحلقة مرةً أخرى ونزيدها بواحد فتصبح 2 وهي أصغر من 5 وهكذا إلى أن تصبح قيمة متغير الحلقة 5 فينتهي تنفيذ الحلقة.

ملاحظة: تبدأ الفهرسة بالقيمة 0، لذا ستكون قيمة i في المرة الخامسة للتنفيذ هي 4 وليس 5.

طبعًا ليس بالضرورة أن تبدأ بقيمة محددة مثل الصفر أو تنتهي بقيمة محددة وإنما يمكنك تحديد أي نطاق تريده كما في هذا المثال:

for i := 20; i < 25; i++ {
    fmt.Println(i)
}

سنبدأ هنا بالقيمة الأولية 20 وننتهي عند الوصول إلى القيمة 25 بحيث تكون أقل تمامًا من 25، أي ننتهي بالعدد 24:

20
21
22
23
24

يمكنك أيضًا التحكم بخطوات الحلقة على عداد الحلقة كما تريد، إذ يمكنك مثلًا تقديم قيمة المتغير بثلاثة بعد كل تكرار كما في المثال التالي:

for i := 0; i < 15; i += 3 {
    fmt.Println(i)
}

نبدأ هنا بالعدد 0 وننتهي عند الوصول إلى 15، وبعد كل تكرار نزيد العدّاد (متغير الحلقة) بثلاثة، وسيكون الخرج كما يلي:

0
3
6
9
12

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

for i := 100; i > 0; i -= 10 {
    fmt.Println(i)
}

وضعنا هنا القيمة الأولية على 100 ووضعنا شرطًا للتوقف i < 0 عند الصفر وجعلنا التقدم عكسيًا بمقدار 10 إلى الخلف بحيث سينقص 10 من قيمة متغير الحلقة بعد كل تكرار، وبالتالي سيكون الخرج كما يلي:

100
90
80
70
60
50
40
30
20
10

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

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

صرّحنا هنا عن المتغير i قبل الدخول إلى الحلقة، إذ يُنفّذ ما بداخل الحلقة طالما أنّ الشرط محقق، أي i أصغر من 5، ولاحظ أيضًا أننا نزيد من قيمة المتغير i في نهاية الكتلة البرمجية الخاصة بالحلقة، فذا لم نزده، فسندخل في حلقة لانهائية، وفي الواقع نحن لم نستغنِ عن تعليمة التهيئة أو التقدّم (الخطوات)، وإنما عرّفناهم بطريقة مختلفة، والغاية من هذا التعريف هو المطابقة مع حلقة while المستخدَمة في باقي اللغات.

ذكرنا التعليمة break في بداية المقال والتي سنستخدِمها عندما يكون شرط التوقف غير مرتبط بعدد محدد من التكرارات وإنما بحدث ما مثل تكرار عملية إدخال كلمة المرور من المستخدِم طالما ليست صحيحةً، ويمكن التعبير عن هكذا حلقة من خلال كتابة for فقط كما يلي:

for {
    if someCondition {
        break
    }
    // do action here
}

مثال آخر على ذلك عندما نقرأ من بنية غير محددة الحجم مثل المخزِّن المؤقت buffer ولا نعرف متى سننتهي من القراءة:

package main

import (
    "bytes"
    "fmt"
    "io"
)

func main() {
    buf := bytes.NewBufferString("one\ntwo\nthree\nfour\n")

    for {
        line, err := buf.ReadString('\n')
        if err != nil {
            if err == io.EOF {

                fmt.Print(line)
                break
            }
            fmt.Println(err)
            break
        }
        fmt.Print(line)
    }
}

يُصرّح في السطر ("buf :=bytes.NewBufferString("one\ntwo\nthree\nfour\n عن مخزِّن مؤقت مع بعض البيانات، ونظرًا لأننا لا نعرف متى سينتهي المخزِّن المؤقت من القراءة، سننشئ حلقة for بدون أيّ بند، أي بدون شرط أو قيمة أولية أو مقدار تقدّم.

نستخدِم داخل الحلقة ('line, err := buf.ReadString('\n لقراءة سطر من المخزِّن المؤقت والتحقق مما إذا كان هناك خطأ في القراءة منه، فإذا كان هناك خطأ، فسنعالج الخطأ ونستخدِم الكلمة المفتاحية break للخروج من حلقة for، فكما نلاحظ أننا من خلال تعليمة break لم نعُد بحاجة إلى كتابة بند الشرط لإيقافها.

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

التكرار على أنواع البيانات المتسلسلة باستخدام RangeClause

من الشائع في جو استخدام الحلقات للتكرار على عناصر أنواع البيانات المتسلسلة أو التجميعية مثل الشرائح والمصفوفات والسلاسل النصية، ولتسهيل هذه العملية يمكننا استخدام حلقة for مع بنية RangeClause، ويمكنك عمومًا استخدام بنية ForClause للتكرار على أيّ نوع من البيانات بطرق محددة طبعًا، إلا أن بنية RangeClause تُعَدّ مُنظّمَةً أكثر وأسهل في القراءة.

بدايةً سنلقي نظرةً على كيفية التكرار باستخدام ForClause في هكذا حالات:

package main

import "fmt"

func main() {
    sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}

    for i := 0; i < len(sharks); i++ {
        fmt.Println(sharks[i])
    }
}

بتشغيل الشيفرة السابقة سنحصل على الخرج التالي:

hammerhead
great white
dogfish
frilled
bullhead
requiem

سنستخدِم الآن بنية RangeClause لتنفيذ الإجراءات نفسها:

package main

import "fmt"

func main() {
    sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}

    for i, shark := range sharks {
        fmt.Println(i, shark)
    }
}

سيُطبع في هذه الحالة كل عنصر في القائمة. هنا استخدمنا المتغيرين i و shark من أجل عملية التكرار ويمكنك استخدام أيّ اسم آخر لهذه المتغيرات، إذ تعيد الكلمة المفتاحية range قيمتين؛ الأولى هي فهرس العنصر والثانية هي قيمته، وبالتالي سيكون الخرج كما يلي:

0 hammerhead
1 great white
2 dogfish
3 frilled
4 bullhead
5 requiem

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

package main

import "fmt"

func main() {
    sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}

    for i, shark := range sharks {
        fmt.Println(shark)
    }
}

سيكون الخرج كما يلي:

src/range-error.go:8:6: i declared and not used

نظرًا لأنّ i قد صُرِّح عنه في الحلقة for، ولكن لم يُستخدم مطلقًا، فسوف يُعطي المُصرّف خطأً يُشير إلى أن هناك متغيرًا قد صُرّح عنه ولم يُستخدَم، وهذا الخطأ ستتلقاه في جو في أيّ وقت تُصرّح فيه عن متغير ولا تستخدِمه، ولحل هذه المشكلة سنستخدِم المتغير المجهول الذي يُعبَّر عنه بالشرطة السفلية _ والذي يشير إلى أنّ هناك قيمة ستُعاد ونعرف ذلك لكن لا نريدها، لذا سنستبدل المتغير i بالمتغير المجهول وسينجح الأمر:

package main

import "fmt"

func main() {
    sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}

    for _, shark := range sharks {
        fmt.Println(shark)
    }
}

سيكون الخرج كما يلي:

hammerhead
great white
dogfish
frilled
bullhead
requiem

يوضِّح الخرج أنّ حلقة for قد تكررت على شريحة السلاسل وطُبع كل عنصر من الشريحة بدون الفهرس.

يمكنك أيضًا استخدام الكلمة range لإضافة عناصر إلى قائمة ما:

package main
import "fmt"
func main() {
    sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}
    for range sharks {
        sharks = append(sharks, "shark")
    }
    fmt.Printf("%q\n", sharks)
}

سيكون الخرج كما يلي:

['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

أضفنا هنا السلسة 'shark' إلى الشريحة sharks عدة مرات من خلال التكرار عليها، أي أضفنا إليها x مرة، بحيث تكون x هي طول القائمة التي نُكرر عليها، ولاحظ هنا أننا لسنا بحاجة إلى استخدام المتغير المجهول _ إطلاقًا، وذلك لأن هكذا حالة مُعرّفة ضمن جو، كما أننا لم نستخدِم أيّ متغير.

يمكننا أيضًا استخدام العامِل range لملء قيم الشريحة كما يلي:

package main

import "fmt"

func main() {
    integers := make([]int, 10)
    fmt.Println(integers)

    for i := range integers {
        integers[i] = i
    }

    fmt.Println(integers)
}

نُصرِّح هنا عن الشريحة integers على أنها شريحة من الأعداد الصحيحة int ونحجز مساحةً لعشرة عناصر مُسبقًا ثم نطبع الشريحة ثم نملأ هذه الشريحة بقيم عناصر فهارسها، ثم نطبعها من جديد:

[0 0 0 0 0 0 0 0 0 0]
[0 1 2 3 4 5 6 7 8 9]

نلاحظ أنه في المرة الأولى للطباعة تكون عناصر الشريحة صفرية، ﻷننا حجزنا 10 عناصر ولم نُعطهم قيمًا، أي القيمة الافتراضية هي 0، لكن في المرة التالية تكون قيم الشريحة من 0 إلى 9 وهذا يُكافئ قيم الفهارس لها.

يمكننا أيضًا استخدام العامِل range للتكرار على محارف سلسلة:

package main

import "fmt"

func main() {
    sammy := "Sammy"

    for _, letter := range sammy {
        fmt.Printf("%c\n", letter)
    }
}

سيكون الخرج كما يلي:

S
a
m
m
y

عند استخدام range للتكرار على عناصر رابطة map، فستُعاد قيمة كل من المفتاح والقيمة:

package main

import "fmt"

func main() {
    sammyShark := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}

    for key, value := range sammyShark {
        fmt.Println(key + ": " + value)
    }
}

سيكون الخرج كما يلي:

color: blue
location: ocean
name: Sammy
animal: shark

ملاحظة: عناصر الرابطة غير مُرتبة، وبالتالي ستُطبع عناصرها بترتيب عشوائي في كل مرة تُنفّذ فيها الشيفرة.

الآن بعد أن تعرّفنا على كيفية التكرار على العناصر المتسلسة، سنتعلم كيفية استخدام الحلقات المتداخلة.

الحلقات المتداخلة Nested Loops

يمكن لحلقات التكرار في جو أن تداخل كما هو الحال في بقية لغات البرمجة، فحلقة التكرار المتداخلة هي الحلقة الموجودة ضمن حلقة تكرار أخرى وهذا مفيد لتكرار عدة عمليات على كل عنصر مثلًا وهي شبيهة بتعليمات if المتداخلة، وتُبنى حلقات التكرار المتداخلة كما يلي:

for {
    [Action]
    for {
        [Action]  
    }
}

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

لنُنشِئ مثالًا يستعمل حلقة for متداخلة لكي نفهم كيف تعمل بدقة، حيث ستمر حلقة التكرار الخارجية في المثال الآتي على شريحة من الأعداد اسمها numList؛ أما حلقة التكرار الداخلية فستمر على شريحة من السلاسل النصية اسمها alphaList:

package main

import "fmt"

func main() {
    numList := []int{1, 2, 3}
    alphaList := []string{"a", "b", "c"}

    for _, i := range numList {
        fmt.Println(i)
        for _, letter := range alphaList {
            fmt.Println(letter)
        }
    }
}

سيظهر الناتج التالي عند تشغيل البرنامج:

1
a
b
c
2
a
b
c
3
a
b
c

يُظهِر الناتج السابق أنَّ البرنامج قد أكمل أول تكرار على عناصر حلقة التكرار الخارجية بطباعة العدد، ومن ثم بدأ بتنفيذ حلقة التكرار الداخلية، لذا طبع المحارف a و b و c على التوالي، وبعد انتهاء تنفيذ حلقة التكرار الداخلية، عاد البرنامج إلى بداية حلقة التكرار الخارجية طابعًا العدد 2، ثم بدأ تنفيذ حلقة التكرار الداخلية، مما يؤدي إلى إظهار a و b و c مجددًا وهكذا.

يمكن الاستفادة من حلقات for المتداخلة عند المرور على عناصر شريحة تتألف من شرائح، فإذا استعملنا حلقة تكرار وحيدة لعرض عناصر شريحة تتألف من عناصر تحتوي على شرائح، فستُعرَض قيم الشرائح الداخلية على أساس عنصر:

package main

import "fmt"

func main() {
    ints := [][]int{
        []int{0, 1, 2},
        []int{-1, -2, -3},
        []int{9, 8, 7},
    }

    for _, i := range ints {
        fmt.Println(i)
    }
}

سيكون الخرج كما يلي:

[0 1 2]
[-1 -2 -3]
[9 8 7]

إذا أردنا الوصول إلى العناصر الموجودة في الشرائح الداخلية، فيمكننا استعمال حلقة for متداخلة:

package main

import "fmt"

func main() {
    ints := [][]int{
        []int{0, 1, 2},
        []int{-1, -2, -3},
        []int{9, 8, 7},
    }

    for _, i := range ints {
        for _, j := range i {
            fmt.Println(j)
        }
    }
}

سيكون الخرج كما يلي:

0
1
2
-1
-2
-3
9
8
7

نستطيع الاستفادة من حلقات for المتداخلة عندما نريد التكرار على عناصر قابلة للتكرار داخل الشرائح.

استخدام تعليمات continue و break

تسمح لك حلقة for بأتمتة وتكرار المهام بطريقة فعّالة، لكن في بعض الأحيان قد يتدخل عامل خارجي في طريقة تشغيل برنامجك، وعندما يحدث ذلك، فربما تريد من برنامجك الخروج تمامًا من حلقة التكرار أو تجاوز جزء من الحلقة قبل إكمال تنفيذها أو تجاهل هذا العامِل الخارجي تمامًا، لذا يمكنك فعل ما سبق باستخدام تعابير break و continue.

تعليمة break

توفِّر لك تعليمة break -والتي تعاملنا معها سابقًا- القدرة على الخروج من حلقة التكرار عند حدوث عامل خارجي، وتوضَع عادةً ضمن تعبير if، وفيما يلي أحد الأمثلة الذي يستعمل تعليمة break داخل حلقة for:

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            fmt.Println("Breaking out of loop")
            break // break here
        }
        fmt.Println("The value of i is", i)
    }
    fmt.Println("Exiting program")
}

بنينا حلقة تكرار for التي تعمل طالما كانت قيمة المتغير i أصغر من 10 وحددنا التقدّم بمقدار 1 بعد كل تكرار، ثم لدينا تعليمة if التي تختبر فيما إذا كان المتغير i مساوٍ للعدد 5، فعند حدوث ذلك، فستُنفَّذ break للخروج من الحلقة.

توجد داخل حلقة التكرار الدالة fmt.Println()‎ التي تُنفَّذ في كل تكرار وتطبع قيمة المتغير i إلى أن نخرج من الحلقة عبر break وهنا يكون لدينا تعليمة طباعة أخرى تطبع Breaking out of loop، ولكي نتأكد أننا خرجنا من الحلقة تركنا تعليمة طباعة أخرى تطبع Exiting program، وبالتالي سيكون الخرج كما يلي:

The value of i is 0
The value of i is 1
The value of i is 2
The value of i is 3
The value of i is 4
Breaking out of loop
Exiting program

يُظهر الناتج السابق أنَّه بمجرد أن أصبحت قيمة المتغير i مساويةً للعدد 5، فسينتهي تنفيذ حلقة التكرار عبر break.

تعليمة continue

تعليمة continue تسمح لنا بتخطي جزء من حلقة التكرار عند حدوث عامِل خارجي مع إكمال بقية الحلقة إلى نهايتها، أي سينتقل تنفيذ البرنامج إلى أوّل حلقة التكرار عند تنفيذ continue، وتوضَع عادةً ضمن تعليمة if.

سنستخدِم البرنامج نفسه الذي استعملناه لشرح التعبير break أعلاه، لكننا سنستخدم التعبير continue بدلًا من break:

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            fmt.Println("Continuing loop")
            continue // break here
        }
        fmt.Println("The value of i is", i)
    }
    fmt.Println("Exiting program")
}

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

The value of i is 0
The value of i is 1
The value of i is 2
The value of i is 3
The value of i is 4
Continuing loop
The value of i is 6
The value of i is 7
The value of i is 8
The value of i is 9
Exiting program

نلاحظ أنَّ السطر الذي يجب أن يحتوي على The value of i is 5 ليس موجودًا في المخرجات، لكن سيُكمَل تنفيذ حلقة التكرار بعد هذه المرحلة مما يؤدي إلى طباعة الأعداد من 6 إلى 10 قبل إنهاء تنفيذ الحلقة.

يمكنك استخدام التعليمة continue لتفادي استخدام تعابير شرطية معقدة ومتداخلة أو لتحسين أداء البرنامج عن طريق تجاهل الحالات التي ستُرفَض نتائجها، وبالتالي ستؤدي تعليمة continue إلى جعل البرنامج يتجاهل تنفيذ حلقة التكرار عند تحقيق شرط معيّن، لكن بعد ذلك سيُكمِل تنفيذ الحلقة مثل العادة.

تعليمة break مع الحلقات المتداخلة

من المهم أن تتذكر أنّ تعليمة break ستوقف فقط تنفيذ الحلقة الداخلية التي يتم استدعاؤها فيها، فإذا كان لديك مجموعة متداخلة من الحلقات، فستحتاج إلى تعليمة break لكل حلقة:

package main

import "fmt"

func main() {
    for outer := 0; outer < 5; outer++ {
        if outer == 3 {
            fmt.Println("Breaking out of outer loop")
            break // break تعليمة
        }
        fmt.Println("The value of outer is", outer)
        for inner := 0; inner < 5; inner++ {
            if inner == 2 {
                fmt.Println("Breaking out of inner loop")
                break // break تعليمة
            }
            fmt.Println("The value of inner is", inner)
        }
    }
    fmt.Println("Exiting program")
}

تتكرر الحلقتان 5 مرات ولكل منهما تعليمة if مع تعليمة break، فالحلقة الخارجية سوف تنكسر أو تُنهى -أي يُطبّق عليها break- إذا كانت قيمة المتغير outer تساوي 3؛ أما الحلقة الداخلية فستنكسر إذا كانت قيمة المتغير inner تساوي 2، وبالتالي سيكون الخرج كما يلي:

The value of outer is 0
The value of inner is 0
The value of inner is 1
Breaking out of inner loop
The value of outer is 1
The value of inner is 0
The value of inner is 1
Breaking out of inner loop
The value of outer is 2
The value of inner is 0
The value of inner is 1
Breaking out of inner loop
Breaking out of outer loop
Exiting program

لاحظ أنه في كل مرة تنكسر فيها الحلقة الداخلية، فإن الحلقة الخارجية لا تنكسر لأن تعليمة break ستكسِر فقط تنفيذ الحلقة الداخلية التي استُدعيَت منها.

الخاتمة

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

ترجمة -وبتصرُّف- للمقالَين How To Construct For Loops in Go و Using Break and Continue Statements When Working with Loops in Go لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: التعامل مع تعليمة التبديل Switch في لغة جو Go
• الحلقات التكرارية في البرمجة
• ما هي البرمجة ومتطلبات تعلمها؟

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

تتوفَّر عدة تعليمات للتفريع branching statements بلغة جو، فقد تناولنا تعليمة if و else و else if والتعليمات الشرطية المتداخلة في المقال السابق كيفية كتابة التعليمات الشرطية if في لغة جو Go، وسننتقل الآن إلى تعليمة تفريع أخرى تدعى switch والتي يُعدّ استخدامها أقل شيوعًا من التعليمات السابقة، ولكن مع ذلك فهي مفيدة أحيانًا للتعبير عن نوع معيّن من التفريع المُتعدِّد multiway branches عندما نريد مثلًا مقارنة قيمة متغير (أو دخل من المستخدِم) بعدة قيم محتملة واتخاذ إجراء محدد بناءً على ذلك.

إن أفضل مثال عملي على ذلك هو برنامج الآلة الحاسبة الذي يُجد ناتج عملية حسابية لعددين، بحيث يكون الدخل هو عملية حسابية -وهذا يكافئ عدة قيم محتملة + أو - أو * أو /- وعددين x و y.، وسيعتمد هنا الإجراء المُتخذ على نوع العملية التي يُدخلها المستخدِم، فإذا أدخل + فسيكون الإجراء x+y، وإذا أدخل - فسيكون x-y، وهكذا.

يمكن تحقيق التفريع المتعدد باستخدام التعليمات الشرطية التي تعرفنا عليها في المقال السابق، لكن يمكن تحقيقه أيضًا باستخدام تعليمة switch كما سنرى في هذا المقال.

بنية التعليمة Switch

عادةً ما تُستخدَم تعليمة التبديل Switch لوصف الحالات التي يكون لدينا فيها عدة إجراءات ممكنة تبعًا لقيم متغير أو عدة متغيرات مُحتمَلة، ويوضح المثال التالي كيف يمكننا تحقيق ذلك باستخدام تعليمات if:

package main

import "fmt"

func main() {
    flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}

    for _, flav := range flavors {
        if flav == "strawberry" {
            fmt.Println(flav, "is my favorite!")
            continue
        }

        if flav == "vanilla" {
            fmt.Println(flav, "is great!")
            continue
        }

        if flav == "chocolate" {
            fmt.Println(flav, "is great!")
            continue
        }

        fmt.Println("I've never tried", flav, "before")
    }
}

سيكون الخرج كما يلي:

chocolate is great!
vanilla is great!
strawberry is my favorite!
I've never tried banana before

نُعرّف بداخل الدالة main شريحةً slice من نكهات المثلجات ثم نستخدِم حلقة for للتكرار على عناصرها ثم نستخدِم ثلاث تعليمات if لطباعة رسائل مختلفة تشير إلى تفضيلات نكهات المثلجات المختلفة، إذ يجب على كل تعليمة if أن تتضمن تعليمة Continue لإيقاف التكرار الحالي في الحلقة لكي لا تُطبَع الرسالة الافتراضية في نهاية كتلة الحلقة.

لاحظ أنه كلما أضفنا نكهةً جديدةً إلى الشريحة السابقة، فسيتعين علينا إضافة التفضيل المقابل لها، وبالتالي الاستمرار في كتابة تعليمات if في كل مرة نضيف فيها عنصرًا جديدًا إلى الشريحة، كما يجب أيضًا تكرار تعليمات if مع الرسائل المكررة كما في حالة "Vanilla" و "chocolate".

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

تبدأ تعليمة التبديل بالكلمة المفتاحية switch متبوعةً بمتغير أو عدة متغيرات لإجراء مقارنات على أساسها (أبسط شكل) متبوعةً بقوسين معقوصَين توضَع ضمنها الحالات المتعددة التي يمكن أن يحملها المتغير أو المتغيرات، وكل من هذه الحالات تبدأ بالكلمة المفتاحية case متبوعةً بقيمة محتملة للمتغير، بحيث تقابل كل حالة إجراءً مُحددًا يُنفَّذ في حال كانت قيمة المتغير تطابق القيمة المحتملة، وسيبدو الأمر أوضح في المثال التالي الذي يكافئ المثال السابق تمامًا:

package main

import "fmt"

func main() {
    flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}

    for _, flav := range flavors {
        switch flav {
        case "strawberry":
            fmt.Println(flav, "is my favorite!")
        case "vanilla", "chocolate":
            fmt.Println(flav, "is great!")
        default:
            fmt.Println("I've never tried", flav, "before")
        }
    }
}

يكون الخرج كما يلي:

chocolate is great!
vanilla is great!
strawberry is my favorite!
I've never tried banana before

نُعرّف بداخل الدالة main كما في المرة السابقة شريحةً slice من نكهات المثلجات ثم نستخدِم حلقة for للتكرار على عناصرها، لكن سنستخدِم في هذه المرة تعليمة التبديل وسنلغي استخدام التعليمة if، إذ وضعنا المتغير flav بعد الكلمة switch وستُختبر قيمة هذا المتغير وستُنفّذ إجراءات محددة بناءً عليها:

• الحالة الأولى سيطبع رسالةً محددةً عندما تكون قيمة هذا المتغير تساوي strawberry.
• الحالة الثانية سيطبع رسالةً محددةً عندما تكون قيمة هذا المتغير تساوي vanilla أو chocolate، ولاحظ أنه في المثال السابق اضطررنا لكتابة تعليمتَي if.
• الحالة الأخيرة هي الحالة الافتراضية وتسمى default حيث أنه إذا لم تتحقق أيّ من الحالات السابقة، فستُنفّذ هذه التعليمة ويطبع الرسالة المحددة، لكن إذا تحققت حالة ما من الحالات السابقة، فلن تُنفّذ هذه التعليمة إطلاقًا.

ملاحظة: لم نحتاج إلى استخدام continue لأن تعليمة التبديل لا تُنفّذ إلا حالةً واحدةً فقط تلقائيًا.

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

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

تُعَدّ تعليمة التبديل مفيدةً في تجميع مجموعات من الشروط الأكثر تعقيدًا لإظهار أنها مرتبطة بطريقة ما، وغالبًا ما يُستخدَم ذلك عند مقارنة متغير أو عدة متغيرات بمجال من القيم بدلًا من القيم المحددة كما في المثال السابق، ويُعَدّ المثال التالي تحقيقًا للعبة تخمين باستخدام تعليمات if التي يمكن أن تستفيد من تعليمة التبديل كما رأينا سابقًا:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    target := rand.Intn(100)

    for {
        var guess int
        fmt.Print("Enter a guess: ")
        _, err := fmt.Scanf("%d", &guess)
        if err != nil {
            fmt.Println("Invalid guess: err:", err)
            continue
        }

        if guess > target {
            fmt.Println("Too high!")
            continue
        }

        if guess < target {
            fmt.Println("Too low!")
            continue
        }

        fmt.Println("You win!")
        break
    }
}

سيختلف الخرج بناءً على العدد العشوائي المحدد ومدى جودة لعبك، وفيما يلي ناتج دورة لعب واحدة:

Enter a guess: 10
Too low!
Enter a guess: 15
Too low!
Enter a guess: 18
Too high!
Enter a guess: 17
You win!

تحتاج لعبة التخمين إلى عدد عشوائي لمقارنة التخمينات به، لذا سنستخدِم الدالة rand.Intn من الحزمة math/rand لتوليده، كما سنستخدِم rand.Seed مولّد الأعداد العشوائية بناءً على الوقت الحالي لضمان حصولنا على قيم مختلفة للمتغير target في كل مرة نلعب فيها، ولاحظ أننا مررنا القيمة 100 إلى الدالة rand.Intn وبالتالي ستكون الأعداد المولَّدة ضمن المجال من 0 إلى 100، وأخيرًا سنستخدِم حلقة for لبدء جمع التخمينات من اللاعب.

تعطينا الدالة fmt.Scanf إمكانية قراءة مدخلات المستخدِم وتخزينها في متغير من اختيارنا، وهنا نريد تخزين القيمة المُدخَلة في المتغير guess، كما نريد أن تكون قيمة هذا المتغير من النوع الصحيح int، لذا سنمرر لهذه الدالة العنصر النائب d% على أساس وسيط أول والذي يشير إلى وجود قيمة من النوع الصحيح، ويكون الوسيط الثاني هو عنوان المتغير guess الذي نريد حفظ القيمة المدخَلة به.

نختبر بعد ذلك فيما إذا كان هناك دخل خاطئ من المستخدِم مثل إدخال نص بدلًا من عدد صحيح ثم نكتب تعليمتَي if بحيث تختبر الأولى فيما إذا كان التخمين الذي أدخله المستخدِم أكبر من قيمة العدد المولَّد ليطبع Too high!‎ وتختبر الثانية فيما إذا كان العدد أصغر ليطبع Too low!‎، وسيكون التخمين في الحالتين خاطئًا، أي القيمة المولّدة لا تتطابق مع التخمين وبالتالي يخسر، طبعًا لاننسى كتابة تعليمة continue بعد كل تعليمة if كما ذكرنا سابقًا، وأخيرًا إذا لم تتحقق أي من الشروط السابقة فإنه يطبع You win!‎ دلالةً إلى أنّ تخمينه صحيح وتتوقف الحلقة لوجود تعليمة break؛ أما إذا لم يكن تخمينه صحيح، فستتكرر الحلقة مرةً أخرى.

لاحظ أنّ استخدام تعليمات if يحجب حقيقة أن مجال القيم التي يُقارن معها المتغير مرتبطة كلها بطريقة ما، كما أنه قد يكون من الصعب معرفة ما إذا كنا قد فاتنا جزء من المجال، وفي المثال التالي سنعدّل المثال السابق باستخدام تعليمة التبديل:

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    target := rand.Intn(100)

    for {
        var guess int
        fmt.Print("Enter a guess: ")
        _, err := fmt.Scanf("%d", &guess)
        if err != nil {
            fmt.Println("Invalid guess: err:", err)
            continue
        }

        switch {
        case guess > target:
            fmt.Println("Too high!")
        case guess < target:
            fmt.Println("Too low!")
        default:
            fmt.Println("You win!")
            return
        }
    }
}

سيكون الخرج مُشابهًا لما يلي:

Enter a guess: 25
Too low!
Enter a guess: 28
Too high!
Enter a guess: 27
You win!

استبدلنا هنا كل تعليمات if بتعليمة التبديل switch، ولاحظ أننا لم نذكر بعد تعليمة التبديل أيّ متغير كما فعلنا في أول مثال من المقال لأن هدفنا هو تجميع الشروط معًا كما ذكرنا، وتتضمن تعليمة التبديل في هذا المثال ثلاث حالات:

• الحالة الأولى عندما تكون قيمة المتغير guess أكبر من target.
• الحالة الثانية عندما تكون قيمة المتغير guess أصغر من target.
• الحالة الأخيرة هي الحالة الافتراضية default، حيث أنه إذا لم تتحقق أي من الحالات السابقة أي أن guess يساوي target ستُنفَّذ هذه التعليمة ويطبع الرسالة المُحددة، لكن إذا تحققت حالة ما من الحالات السابقة فلن تُنفّذ هذه التعليمة إطلاقًا، إذًا تُشير هذه الحالة إلى أن التخمين يطابق القيمة المولّدة.

ملاحظة: لا حاجة إلى استخدام continue لأن تعليمة التبديل لاتُنفّذ إلا حالة واحدة فقط تلقائيًا.

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

التعليمة fallthrough: نفذ الخطوة التالية أيضا

ربما ترغب بإعادة تنفيذ الشيفرة الموجودة ضمن حالة أخرى، وهنا يمكنك الطلب من جو أن يُشغّل الشيفرة التي تتضمنها الحالة التالية من خلال وضع التعليمة fallthrough في نهاية شيفرة الحالة الحالية، وفي المثال التالي سنُعدِّل المثال الذي عرضناه في بداية المقال والمتعلق بنكهات المثلجات لكي نوضّح كيف يمكننا استخدام هذه التعليمة فيه:

package main

import "fmt"

func main() {
    flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}

    for _, flav := range flavors {
        switch flav {
        case "strawberry":
            fmt.Println(flav, "is my favorite!")
            fallthrough
        case "vanilla", "chocolate":
            fmt.Println(flav, "is great!")
        default:
            fmt.Println("I've never tried", flav, "before")
        }
    }
}

سيكون الخرج كما يلي:

chocolate is great!
vanilla is great!
strawberry is my favorite!
strawberry is great!
I've never tried banana before

نُعرّف داخل الدالة main شريحةً slice من نكهات المثلجات ثم نستخدِم حلقة for للتكرار على عناصرها ثم نستخدِم تعليمة التبديل ونضع المتغير flav بعد الكلمة switch بحيث تُختبر قيمته وتُنفَّذ إجراءات محددة بناءً عليها:

• الحالة الأولى سيطبع رسالةً محددةً عندما تكون قيمة هذا المتغير تساوي vanilla أو chocolate.
• الحالة الثانية سيطبع strawberry is my favorite!‎ عندما تكون قيمة هذا المتغير تساوي strawberry ثم سيُنفّذ التعليمة fallthrough التي تؤدي إلى تنفيذ شيفرة الحالة التالية لها، وبالتالي سيطبع strawberry is great!‎ أيضًا.
• الحالة الأخيرة هي الحالة الافتراضية default.

لا يستخدِم المطورون تعليمة fallthrough في لغة جو كثيرًا لأنه من الممكن الاستغناء عنها بتعريف دالة تؤدي الغرض واستدعائها ببساطة، وعمومًا لا يُنصَح باستخدامها.

الخاتمة

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

ترجمة -وبتصرف- للمقال How To Construct For Loops in Go لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: كيفية كتابة التعليمات الشرطية if في لغة جو Go
• كتابة برنامجك الأول في جو Go
• مقدمة في البرمجة الشرطية

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

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

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

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

التعليمة if

سنبدأ بالتعليمة ‎if‎ والتي تتحقق مما إذا كان شرطًا محدَّدًا محقّقًا true أم لا false، ففي حال تحقق الشرط، فستُنفَّذ الشيفرة المقابلة، وإلا فسيتابع البرنامج في مساره الطبيعي، ولنبدأ بأمثلة عملية توضح ذلك، لذا افتح ملفًا واكتب الشيفرة التالية:

package main

import "fmt"

func main() {
    grade := 70

    if grade >= 65 {
        fmt.Println("Passing grade")
    }
}

أعطينا للمتغير ‎grade‎ القيمة الصحيحة ‎70‎ ثم استخدمنا التعليمة ‎if‎ لتقييم ما إذا كان أكبر من أو يساوي ‎65‎ وفي تلك الحالة سيطبع البرنامج السلسلة النصية التالية: Passing grade.

احفظ البرنامج بالاسم ‎grade.go‎ ثم نفّذه في بيئة البرمجة المحلية من نافذة الطرفية باستخدام الأمر ‎go run grade.go، وفي هذه الحالة تلبي الدرجة 70 تلبي لأنها أكبر من 65، لذلك ستحصل على الخرج التالي عند تنفيذ البرنامج:

Passing grade

لنغيّر الآن نتيجة هذا البرنامج عبر تغيير قيمة المتغير ‎grade‎ إلى ‎60‎:

package main

import "fmt"

func main() {
    grade := 60

    if grade >= 65 {
        fmt.Println("Passing grade")
    }
}

لن نحصل على أية خرج بعد حفظ وتنفيذ الشيفرة لأنّ الشرط لم يتحقق ولم نأمر البرنامج بتنفيذ تعليمة أخرى.

لنأخذ مثالًا آخرًا، إذ نريد التحقق مما إذا كان رصيد الحساب المصرفي أقل من 0، لذا سننشئ ملفًا باسم ‎account.go‎ ونكتب البرنامج التالي:

package main

import "fmt"

func main() {
    balance := -5

    if balance < 0 {
        fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
    }
}

سنحصل على الخرج التالي عند تنفيذ البرنامج باستخدام الأمر go run account.go‎‎:

Balance is below 0, add funds now or you will be charged a penalty.

أعطينا للمتغير ‎balance‎ القيمة ‎-5‎ وهي أقل من 0 في البرنامج السابق، ولمَّا كان الرصيد مستوفيًا لشرط التعليمة ‎if‎ أي ‎balance < 0‎، فسنحصل على سلسلة نصية في الخرج بمجرد حفظ الشيفرة وتنفيذها، وإذا غيّرنا الرصيد إلى القيمة 0 أو إلى عدد موجب مرةً أخرى، فلن نحصل على أيّ خرج.

التعليمة else

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

package main

import "fmt"

func main() {
    grade := 60

    if grade >= 65 {
        fmt.Println("Passing grade")
    } else {
        fmt.Println("Failing grade")
    }
}

تساوي قيمة المتغير ‎‎grade‎‎ العدد ‎60‎، لذلك فشرط التعليمة ‎if‎ غير متحقق، وبالتالي لن يطبع البرنامج ‎درجة النجاح‎، إذ تخبر التعليمة ‎else‎ البرنامج أنه عليه طباعة السلسلة النصية Failing grade، لذا عندما نحفظ البرنامج وننفّذه، فسنحصل على الخرج التالي:

Failing grade

إذا عدّلنا البرنامج وأعطينا المتغير grade القيمة ‎65‎ أو أعلى منها، فسنحصل بدلًا من ذلك على Passing grade، ولإضافة التعليمة ‎else‎ إلى مثال الحساب المصرفي، سنعيد كتابة الشيفرة كما يلي:

package main

import "fmt"

func main() {
    balance := 522

    if balance < 0 {
        fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
    } else {
        fmt.Println("Your balance is 0 or above.")
    }
}

سنحصل على الخرج التالي:

Your balance is 0 or above.

غيّرنا هنا قيمة المتغير ‎balance‎ إلى عدد موجب لكي تُنفَّذ الشيفرة المقابلة للتعليمة ‎else‎، فإذا أردت تنفيذ الشيفرة المقابلة للتعليمة ‎if‎، فغيِّر القيمة إلى عدد سالب.

من خلال دمج العبارتين ‎if‎ و ‎else‎، فأنت تنشئ تعليمة شرطية مزدوجة والتي ستجعل الحاسوب ينفذ شيفرة برمجية معينّة سواءً تحقق شرط ‎if‎ أم لا.

التعليمة else if

عملنا حتى الآن على تعليمات شرطية ثنائية، أي إذا تحقق الشرط، فنفِّذ شيفرةً ما، وإلا، فنفِّذ شيفرةً أخرى فقط، لكن قد تريد في بعض الحالات برنامجًا يتحقق من عدة حالات شرطية، ولأجل هذا سنستخدِم التعليمة Else if والتي تُكتب في جو بالصورة else if، إذ تشبه هذه التعليمة تعليمة ‎if‎ ومهمتها التحقق من شرط إضافي.

قد نرغب في برنامج الحساب المصرفي في الحصول على ثلاثة مخرجات مختلفة مقابلة لثلاث حالات مختلفة:

• الرصيد أقل من 0.
• الرصيد يساوي 0.
• الرصيد أعلى من 0.

لذا ستوضع التعليمة else if بين التعليمة ‎if‎ والتعليمة ‎else‎ كما يلي:

package main

import "fmt"

func main() {
    balance := 522

    if balance < 0 {
        fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
    } else if balance == 0 {
        fmt.Println("Balance is equal to 0, add funds soon.")
    } else {
        fmt.Println("Your balance is 0 or above.")
    }
}

هناك الآن ثلاثة مخرجات محتملة يمكن أن تُطبع عند تنفيذ البرنامج وهي:

• إذا كان المتغير ‎balance‎ يساوي ‎0‎، فسنحصل على الخرج من التعليمة else if‎ (أي ‎الرصيد يساوي 0، أضف مبلغًا قريبًا‎).
• إذا ضُبِط المتغير ‎balance‎على عدد موجب، فسنحصل على المخرجات من التعليمة ‎else‎ (أي ‎رصيدك أكبر من 0).
• إذا ضُبِط المتغير ‎balance‎على عدد سالب، فسنحصل على المخرجات من التعليمة ‎if‎ (أي ‎الحساب فارغ، أضف مبلغا الآن أو ستحصل على غرامة‎).

إذا أردنا أن نأخذ بالحسبان أكثر من ثلاثة احتمالات، فيمكننا كتابة عدة تعليمات else if‎ في الشيفرة البرمجية، ولنُعِد الآن كتابة البرنامج ‎grade.go‎ بحيث يقابل كل نطاق من الدرجات العددية درجة حرفية محددة:

• الدرجة 90 أو أعلى تكافئ الدرجة A.
• من 80 إلى 89 تكافئ الدرجة B.
• من 70 إلى 79 تكافئ الدرجة C.
• من 65 إلى 69 تكافئ الدرجة D.
• الدرجة 64 أو أقل تكافئ الدرجة F.

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

package main

import "fmt"

func main() {
    grade := 60

    if grade >= 90 {
        fmt.Println("A grade")
    } else if grade >= 80 {
        fmt.Println("B grade")
    } else if grade >= 70 {
        fmt.Println("C grade")
    } else if grade >= 65 {
        fmt.Println("D grade")
    } else {
        fmt.Println("Failing grade")
    }
}

تُنفّذ تعليمات else if‎ بالترتيب، وسيكمل هذا البرنامج الخطوات التالية:

• إذا كانت الدرجة أكبر من 90، فسيطبع البرنامج الدرجة A، وإذا كانت الدرجة أقل من 90، فسيستمر البرنامج إلى التعليمة التالية.
• إذا كانت الدرجة أكبر من أو تساوي 80، فسيطبع البرنامج الدرجة B‎، إذا كانت الدرجة تساوي 79 أو أقل، فسيستمر البرنامج إلى التعليمة التالية.
• إذا كانت الدرجة أكبر من أو تساوي 70، فسيطبعُ البرنامجُ الدرجة C، إذا كانت الدرجة تساوي 69 أو أقل، فسيستمر البرنامج إلى التعليمة التالية.
• إذا كانت الدرجة أكبر من أو تساوي 65، فسيطبع البرنامج الدرجة D، وإذا كانت الدرجة تساوي 64 أو أقل، فسيستمر البرنامج إلى التعليمة التالية.
• سيطبع البرنامج ‎Failing grade لأنه لم تستوفى أي من الشروط المذكورة أعلاه.

تعليمات if المتداخلة

يمكنك الانتقال إلى التعليمات الشرطية المتداخلة بعد أن تتعود على التعليمات ‎if‎ و else if‎ و ‎else، إذ يمكننا استخدام تعليمات ‎if‎ المتداخلة في الحالات التي نريد فيها التحقق من شرط ثانوي بعد التأكد من تحقق الشرط الرئيسي، وبالتالي يمكننا حشر تعليمة if-else داخل تعليمة if-else أخرى، ولنلقِ نظرةً على صياغة ‎if‎ المتداخلة:

if statement1 { // الخارجية if تعليمة
    fmt.Println("true")

    if nested_statement { // المتداخلة if تعليمة
        fmt.Println("yes")
    } else { // المتداخلة else تعليمة
        fmt.Println("no")
    }

} else { // الخارجية else تعليمة
    fmt.Println("false")
}

هناك عدة مخرجات محتملة لهذه الشيفرة:

• إذا كانت التعليمة ‎statement1‎ صحيحةً، فسيتحقق البرنامج مما إذا كانت ‎nested_statement‎ صحيحةً أيضًا، فإذا كانت كلتا الحالتين صحيحتين، فسنحصل على المخرجات التالية:

true
yes

• ولكن إذا كانت ‎statement1‎ صحيحةً و ‎nested_statement‎ خاطئةً، فسنحصل على المخرجات التالية:

true
no

• وإذا كانت ‎statement1‎ خاطئةً، فلن تُنفّذ تعليمة if-else المتداخلة على أيّ حال، لذلك ستُنفّذ التعليمة ‎else‎ وحدها وستكون المخرجات كما يلي:

false

يمكن أيضًا استخدام عدة تعليمات ‎if‎ متداخلة في الشيفرة:

if statement1 { // الخارجية if
    fmt.Println("hello world")

    if nested_statement1 { // المتداخلة الأولى if
        fmt.Println("yes")

    } else if nested_statement2 { // المتداخلة الأولى else if
        fmt.Println("maybe")

    } else { // المتداخلة الأولى else
        fmt.Println("no")
    }

} else if statement2 { // الخارجية else if
    fmt.Println("hello galaxy")

    if nested_statement3 { // المتداخلة الثانية if
        fmt.Println("yes")
    } else if nested_statement4 { // المتداخلة الثانية else if
        fmt.Println("maybe")
    } else { // المتداخلة الثانية else
        fmt.Println("no")
    }

} else { // الخارجية else
    statement("hello universe")
}

توجد في الشيفرة البرمجية أعلاه تعليمات ‎if‎ و else if متداخلة داخل كل تعليمات ‎if‎، إذ سيفسح هذا مجالًا لمزيد من الخيارات في كل حالة.

دعنا نلقي نظرةً على مثال لتعليمات ‎if‎ متداخلة في البرنامج ‎grade.go، إذ يمكننا التحقق أولًا مما إذا كان الطالب قد حقق درجة النجاح (أكبر من أو تساوي 65%) ثم نحدد العلامة المقابلة للدرجة، فإذا لم يحقق الطالب درجة النجاح، فلا داعي للبحث عن العلامة المقابلة للدرجة، وبدلًا من ذلك، يمكن أن نجعل البرنامج يطبع سلسلة نصية فيها إعلان عن رسوب الطالب، وبالتالي ستبدو الشيفرة المعدلة كما يلي:

package main

import "fmt"

func main() {
    grade := 92
    if grade >= 65 {
        fmt.Print("Passing grade of: ")

        if grade >= 90 {
            fmt.Println("A")

        } else if grade >= 80 {
            fmt.Println("B")

        } else if grade >= 70 {
            fmt.Println("C")

        } else if grade >= 65 {
            fmt.Println("D")
        }

    } else {
        fmt.Println("Failing grade")
    }
}

إذا أعطينا للمتغير ‎grade‎ القيمة ‎92‎، فسيتحقق الشرط الأول وسيطبع البرنامج العبارة "‎Passing grade of:‎"، بعد ذلك سيتحقق مما إذا كانت الدرجة أكبر من أو تساوي 90، وبما أنّ هذا الشرط محقق أيضًا، فستُطبع ‎A‎؛ أما إذا أعطينا للمتغير ‎grade‎ القيمة ‎60‎، فلن يتحقق الشرط الأول، لذلك سيتخطى البرنامج تعليمات ‎if‎ المتداخلة وينتقل إلى التعليمة ‎else‎ ويطبع ‎Failing grade.

يمكننا بالطبع إضافة المزيد من الخيارات واستخدام طبقة ثانية من تعليمات ‎if‎ المتداخلة، فربما نودّ إضافة الدرجات التفصيلية A+‎ و A و A-‎، إذ يمكننا إجراء ذلك عن طريق التحقق أولًا من اجتياز درجة النجاح ثم التحقق مما إذا كانت الدرجة تساوي 90 أو أعلى ثم التحقق مما إذا كانت الدرجة تتجاوز 96، وفي تلك الحالة ستقابل العلامة A+، وإليك المثال التالي:

...
if grade >= 65 {
    fmt.Print("Passing grade of: ")

    if grade >= 90 {
        if grade > 96 {
            fmt.Println("A+")

        } else if grade > 93 && grade <= 96 {
            fmt.Println("A")

        } else {
            fmt.Println("A-")
        }
...

سيؤدي البرنامج السابق ما يلي في حال تعيين المتغير ‎grade‎ على القيمة ‎96‎:

• التحقق مما إذا كانت الدرجة أكبر من أو تساوي 65 (صحيح).
• طباعة ‎Passing grade of:‎
• التحقق مما إذا كانت الدرجة أكبر من أو تساوي 90 (صحيح).
• التحقق مما إذا كانت الدرجة أكبر من 96 (خطأ).
• التحقق مما إذا كانت الدرجة أكبر من 93 وأقل من أو تساوي 96 (صحيح).
• طباعة A.
• تجاوز التعليمات الشرطية المتداخلة وتنفيذ باقي الشيفرة.

سيكون خرج البرنامج إذا كانت الدرجة تساوي 96 كما يلي:

Passing grade of: A

تساعد تعليمات ‎if‎ المتداخلة على إضافة عدة مستويات من الشروط الفرعية إلى الشيفرة.

الخاتمة

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

ترجمة -وبتصرف- للمقال How To Write Conditional Statements in Go لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: فهم مجال رؤية الحزم Visibility في لغة جو Go
• مقدمة في البرمجة الشرطية
• تعلم أساسيات البرمجة

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

تُعَدّ الرؤية Visibility هي النطاق الذي يمكن الوصول للحزمة ضمنه، فإذا صرّحت مثلًا عن متغير داخل دالة ضمن حزمة A، فلن تتمكن من الوصول إلى هذا المتغير إلى ضمن الدالة التي صُرّح عنه فيها وضمن الحزمة A فقط، في حين إذا صرّحت عن المتغير نفسه ضمن الحزمة وليس بداخل دالة أو أيّ نطاق آخر، فيمكنك السماح للحزم الأخرى بالوصول إلى هذا المتغير أو لا.

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

تتمثّل إحدى طرق الضبط الدقيق لمثل هذه العمليات في تقييد الوصول -أي تقييد الرؤية-، بحيث تسمح بالوصول إلى أجزاء مُحددة فقط من الحزمة -أي الأجزاء القابلة للاستخدام فقط-، وبذلك تتمكّن من إجراء التغييرات الداخلية على حِزَمك مع تقليل احتمالية التأثير على استخدام المطورين للحزمة.

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

المتطلبات

• أن يكون لديك مساحة عمل خاصة في لغة جو، فإذا لم يكن لديك، فاتبع سلسلة المقالات التالية، فقد تحدّثنا عن ذلك في بداية السلسلة
• تثبيت لغة جو Go وإعداد بيئة برمجة محلية على أبونتو Ubuntu
• تثبيت لغة جو وإعداد بيئة برمجة محلية على نظام ماك macOS
• تثبيت لغة جو وإعداد بيئة برمجة محلية على ويندوز

سيعتمد المقال على بنية المجلد التالية:

.
├── bin 
│ 
└── src
    └── github.com
        └── gopherguides

العناصر المصدرة وغير المصدرة

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

لكي نجعل عنصرًا ما -مثل متغير أو دالة أو نوع بيانات جديد …إلخ- داخل الحزمة مُصدّرًا، سنكتب أول محرف منه كبيرًا، أي إذا كان اسم الدالة hsoub، فستكون مرئيةً فقط ضمن الحزمة نفسها وتكون غير مُصدّرة؛ أما إذا كتبناها Hsoub، فستكون مرئيةً من خارج الحزمة وتكون مُصدّرة.

لاحظ المثال التالي وانتبه لحالة أول محرف في كل التصريحات:

package greet

import "fmt"

var Greeting string

func Hello(name string) string {
    return fmt.Sprintf(Greeting, name)
}

من الواضح أنّ هذه الشيفرة موجودة ضمن الحزمة greet، ولاحظ أننا صرّحنا عن متغير اسمه Greeting وجعلنا أول محرف كبيرًا، لذا فهذا المتغير سيكون مُصدّرًا ويمكن رؤيته من خارج الحزمة، وينطبق الأمر نفسه على الدالة Hell، فقد كتبنا أول محرف منها كبيرًا.

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

تحديد رؤية الحزمة

سنُنشئ الحزمة logging مع الأخذ بالحسبان ما نريده مرئيًا وما نريده غير مرئي لكي يكون لدينا نظرة أوضح عن آلية عمل قابلية الرؤية في برامجنا.

ستكون هذه الحزمة مسؤولةً عن تسجيل أيّ رسالة من البرنامج إلى وحدة التحكم console، كما يُحدد المستوى الذي يحدث عنده التسجيل، إذ يصف المستوى نوع السجل وسيكون أحد الحالات الثلاث: معلومات info أو تحذير warning أو خطأ error، لذا أنشئ بدايةً مجلد الحزمة logging داخل المجلد src كما يلي:

$ mkdir logging

انتقل إلى مجلد الحزمة:

$ cd logging

أنشئ ملف logging.go باستخدام محرر شيفرات مثل نانو nano:

$ nano logging.go

ضع فيه الشيفرة التالية:

package logging

import (
    "fmt"
    "time"
)

var debug bool

func Debug(b bool) {
    debug = b
}

func Log(statement string) {
    if !debug {
        return
    }

    fmt.Printf("%s %s\n", time.Now().Format(time.RFC3339), statement)
}

تصف التعليمة الأولى في هذه الشيفرة أننا ضمن الحزمة logging، وتوجد لدينا ضمن هذه الحزمة دالتين مُصدّرتين هما Debug و Log، وبالتالي يمكن استدعاء هذه الدوال من أيّ حزمة أخرى تستورد الحزمة logging، ولدينا أيضًا متغير غير مُصدّر اسمه debug، وبالتالي لايمكن الوصول إليه إلى ضمن الحزمة.

على الرغم من أنه لدينا متغير ودالة بالاسم نفسه "debug"، إلا أنهما مختلفان، فالدالة بدأت بمحرف كبير؛ أما المتغير، فقد بدأ بمحرف صغير ولغة جو حساسة لحالة المحارف.

احفظ الملف بعد وضع الشيفرة فيه، ولاستخدام الحزمة في مكان آخر، يجب استيرادها، لذا سنُنشئ حزمةً جديدةً ونجرب عليها، وبالتالي انتقل إلى المجلد logging وأنشئ مجلدًا اسمه cmd وانتقل إليه:

$ cd ..
$ mkdir cmd
$ cd cmd

أنشئ الملف main.go بداخله:

$ nano main.go

أضف إليه الشيفرة التالية:

package main

import "github.com/gopherguides/logging"

func main() {
    logging.Debug(true)

    logging.Log("This is a debug statement...")
}

أصبح لدينا الآن كامل الشيفرة المطلوب، لكن نحتاج قبل تشغيلها إلى إنشاء ملفَي ضبط حتى تعمل التعليمات البرمجية بطريقة صحيحة.

تُستخدَم وحدات لغة جو Go Modules لضبط اعتماديات الحزمة لاستيراد الموارد، إذ تُعَدّ وحدات لغة جو ملفات ضبط موضوعة في مجلد الحزمة الخاص بك وتخبر المُصرّف بمكان استيراد الحزم منه، ولن نتحدث عن وحدات لغة جو في هذا المقال، لكن سنكتب السطرين التاليين لكي تعمل الشيفرة السابقة، لذا افتح ملف go.mod ضمن المجلد cmd:

$ nano go.mod

ثم ضع السطرين التاليين فيه:

module github.com/gopherguides/cmd
replace github.com/gopherguides/logging => ../logging

يُخبر السطر الأول المُصرّف أنّ الحزمة cmd لديها مسار الملف github.com/gopherguides/cmd؛ أما السطر الثاني، فيُخبر المُصرّف أنّ الحزمة github.com/gopherguides/logging يمكن العثور عليها محليًا على القرص في المجلد ‎../logging.

نحتاج إيضًا إلى وجود ملف go.mod بداخل الحزمة logging، لذا سننتقل إلى مجلدها ثم سننشئ هذا الملف بداخله:

$ cd ../logging
$ nano go.mod

أضف الشيفرة التالية إلى الملف:

module github.com/gopherguides/logging

يخبر هذا المترجم أنّ حزمة logging التي أنشأناها هي الحزمة github.com/gopherguides/logging، إذ سيسمح لنا ذلك باستيراد الحزمة من داخل الحزمة main كما يلي:

package main

import "github.com/gopherguides/logging"

func main() {
    logging.Debug(true)

    logging.Log("This is a debug statement...")
}

يجب أن يكون لديك الآن بنية المجلد التالية:

├── cmd
│   ├── go.mod
│   └── main.go
└── logging
    ├── go.mod
    └── logging.go

أصبح بإمكاننا الآن تشغيل البرنامج main من حزمة cmd بالأوامر التالية بعد أن أنشأنا جميع ملفات الضبط:

$ cd ../cmd
$ go run main.go

سنحصل على رسالة تطبع التوقيت وتقول أن هذه تعليمة تنقيح debug:

2019-08-28T11:36:09-05:00 This is a debug statement...

يطبع البرنامج الوقت الحالي بتنسيق RFC 3339 متبوعًا بالتعليمة التي أرسلناها إلى المُسجّل logger، وقد صُمِّم RFC 3339 لتمثيل الوقت على الإنترنت ومن الشائع استخدامه في ملفات التسجيل والتتبع log files.

بما أن الدالتين Debug و Log هما دوال مُصدّرة، لذا يمكن استخدامهما في الحزمة main، لكن لا يمكن استخدام المتغير debug في حزمة logging، وإذا حاولت الوصول إليه، فستحصل على خطأ في وقت التصريف compile-time error.

سنضيف السطر (fmt.Println(logging.debug إلى main.go:

package main

import "github.com/gopherguides/logging"

func main() {
    logging.Debug(true)

    logging.Log("This is a debug statement...")

    fmt.Println(logging.debug)
}

احفظ وشغل الملف، إذ ستحصل على الخطأ التالي (لا يمكن الإشارة إلى العنصر debug لأنه غير مُصدّر):

. . .
./main.go:10:14: cannot refer to unexported name logging.debug

سنتعرّف الآن على كيفية تصدير الحقول والتوابع من داخل السجلات structs بعد أن تعرّفنا على الملفات المُصدّرة وغير المُصدّرة.

نطاق الرؤية داخل السجلات structs

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

تخيل أن تضبط المتغير Debug على true ويأتي شخص آخر لا تعرفه يستخدم الحزمة نفسها ويضبطه على false، لذا سنحل هذه المشكلة من خلال استخدام مفهوم النسخ الذي تتبناه السجلات Structs في جو، وبالتالي كل شخص يستخدِم هذه الحزمة سيأخذ نسخةً مستقلةً منها، وبالتالي سنتجنب مثل هذه المشاكل.

سنعدّل الآن الحزمة logging كما يلي:

package logging

import (
    "fmt"
    "time"
)

type Logger struct {
    timeFormat string
    debug      bool
}

func New(timeFormat string, debug bool) *Logger {
    return &Logger{
        timeFormat: timeFormat,
        debug:      debug,
    }
}

func (l *Logger) Log(s string) {
    if !l.debug {
        return
    }
    fmt.Printf("%s %s\n", time.Now().Format(l.timeFormat), s)
}