البرمجة بلغة go كيفية كتابة التعليمات الشرطية if في لغة جو 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
• مقدمة في البرمجة الشرطية
• تعلم أساسيات البرمجة