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

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

يمكن التفكير في أنواع المتغيرات كما العالم الحقيقي، فنحن نتعامل مثلًا مع الأعداد من مجموعات عددية مختلفة مثل مجموعة الأعداد الطبيعية (0 ، 1 ، 2 ، …) والأعداد الصحيحة (… ، -1 ، 0 ، 1 ، …) والأعداد غير الكسرية مثل π.

عند التعامل مع المسائل الرياضية قد نجمع بين الأعداد التي تنتمي إلى مجموعات عددية مختلفة لنحصل على نتيجة ما مثلًا إضافة العدد 5 إلى π:

5 + π

يمكننا الآن الاحتفاظ بالمعادلة كما هي لتكون إجابةً أو يمكننا تقريب العدد π إلى منزلة عشرية مناسبة ثم جمعه مع العدد 5، أي كما يلي:

5 + π = 5 + 3.14 = 8.14

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

shark + 8

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

الأعداد الصحيحة

كما هو الحال في الرياضيات، فإن الأعداد الصحيحة Integers في الحاسب هي أعداد موجبة أو سالبة إضافةً إلى الصفر، أي (‎… ، -1 ، 0 ، 1 ، …‎).

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

fmt.Println(-459)

والنتيجة هي:

-459

أو يمكنك تعريف متغير من النوع الصحيح ليمثل هذا العدد كما يلي:

var absoluteZero int = -459
fmt.Println(absoluteZero)

والنتيجة هي:

-459

يمكنك أيضًا إجراء العمليات الحسابية على الأعداد الصحيحة في جو، ففي الشيفرة التالية سنستخدِم معامل الإسناد ‎:=‎ لتعريف وتقييم المتغير sum:

sum := 116 - 68
fmt.Println(sum)

والنتيجة هي:

48

نلاحظ أنه قد طُرح العدد 68 من العدد 116 وخُزّن الناتج 48 في المتغيّر sum.

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

الأعداد العشرية

يُعَدّ العدد ذو الفاصلة العشرية Floating-Point عددًا عشريًا ويمكن كتابته على صورة حاصل ضرب في على النحو التالي: 10*12.5 = 2^10*1.25 = 125.

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

fmt.Println(-459.67)

والنتيجة هي:

-459.67

يمكنك أيضًا تعريف متغير يمثّله كما يلي:

absoluteZero := -459.67
fmt.Println(absoluteZero)

والنتيجة هي:

-459.67

يمكنك أيضًا إجراء العمليات الحسابية عليه كما فعلنا مع الأعداد الصحيحة:

var sum = 564.0 + 365.24
fmt.Println(sum)

والنتيجة هي:

929.24

يجب أن تأخذ في الحسبان أنّ العدد 3 لا يساوي العدد 3.0، إذ يشير العدد 3 إلى عدد صحيح في حين 3.0 إلى عدد عشري.

حجم الأنواع العددية

يحتوي جو على نوعين من البيانات العددية بالإضافة إلى التمييز بين الأعداد الصحيحة والعشرية، وهما الساكنة static والديناميكية dynamic، فالنوع الأول مستقل عن المعمارية architecture-independent، أي أنّ حجم البيانات بواحدة البِتّ bit لا يتغير بغض النظر عن الجهاز الذي تعمل عليه الشيفرة.

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

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

يُعَدّ النوع الثاني نوعًا خاصًا بالتنفيذ implementation-specific، إذ يمكن هنا أن يختلف حجم البِتّ بناءً على المعمارية التي بُنيَ البرنامج عليها، فإذا استخدمت النوع int، فسيكون حجم المتغير هو 32 بِتّ عند تصريف برنامج جو لمعمارية 32 بِتّ؛ أما إذا صُرِّف البرنامج بمعمارية 64 بِتّ، فسيكون حجم المتغير 64 بِتّ، لذا يُسمى ديناميكيًا.

هناك أنواع لأنواع البيانات نفسها إضافةً إلى أنواع البيانات ذات الأحجام المختلفة، فالأعداد الصحيحة مثلًا لها نوعين أساسيين هما ذات إشارة signed وعديمة الإشارة unsigned، فالنوع int8 هو عدد صحيح له إشارة سالبة أو موجبة ويمكن أن يكون له قيمة من ‎-128 إلى 127. أما النوع uint8 فهو عدد صحيح عديم الإشارة أي موجب دومًا، ويمكن أن يكون له فقط قيمة موجبة من 0 إلى 255.

يمتلك جو الأنواع التالية المستقلة عن نوع المعمارية architecture-independent للأعداد الصحيحة:

uint8       unsigned  8-bit integers (0 to 255)
uint16      unsigned 16-bit integers (0 to 65535)
uint32      unsigned 32-bit integers (0 to 4294967295)
uint64      unsigned 64-bit integers (0 to 18446744073709551615)
int8        signed  8-bit integers (-128 to 127)
int16       signed 16-bit integers (-32768 to 32767)
int32       signed 32-bit integers (-2147483648 to 2147483647)
int64       signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

تأتي أعداد الفاصلة العشرية والأعداد المركبة أو العقدية complex numbers أيضًا بأحجام مختلفة:

float32     IEEE-754 32-bit floating-point numbers
float64     IEEE-754 64-bit floating-point numbers
complex64   complex numbers with float32 real and imaginary parts
complex128  complex numbers with float64 real and imaginary parts

يوجد أيضًا نوعان بديلان alias للأعداد بغية إعطائها اسمًا هادفًا:

byte        alias for uint8
rune        alias for int32

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

الاسم البديل رون rune مختلف قليلًا، فعلى عكس البايت byte و uint8 اللذان يمثلان البيانات نفسها، يمكن أن يكون الرون بايتًا واحدًا أو أربعة بايتات، أي مجالًا من 8 إلى 32 بت وهو مايحدده النوع int32، كما يُستخدم الرون لتمثيل محرف الترميز الموحد يونيكود Unicode (معيار يُمكّن الحواسيب من تمثيل النصوص المكتوبة بأغلب نُظم الكتابة ومعالجتها، بصورة متناسقة).

يحتوي جو إضافةً إلى ذلك على الأنواع التالية الخاصة بالتنفيذ:

uint     unsigned, either 32 or 64 bits
int      signed, either 32 or 64 bits
uintptr  unsigned integer large enough to store the uninterpreted bits of a pointer value

يُحدَّد حجم الأنواع الخاصة بالتنفيذ من خلال المعمارية التي صُرّف البرنامج من أجلها.

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

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

تحدثنا سابقًا أنّ هناك أنواع مستقلة عن المعمارية وأنواع خاصة بالتنفيذ، فبالنسبة لبيانات الأعداد الصحيحة من الشائع في جو استخدام أنواع تنفيذ مثل int أو uint بدلًا من int64 أوuint64، إذ ينتج عن ذلك عادةً سرعة معالجة أكبر على المعمارية المستهدفة، فإذا كنت تستخدم int64 مثلًا وأنجزت عملية التصريف على معمارية 32 بِتّ، فسيستغرق الأمر ضعف الوقت على الأقل لمعالجة هذه القيم بحيث تستغرق دورات معالجة إضافية لنقل البيانات من معمارية لأخرى؛ أما إذا استخدمت int بدلًا من ذلك، فسيعرّفه البرنامج على أنه حجم 32 بِتّ لمعمارية 32 بِتّ وسيكون أسرع في المعالجة.

إذا كنت تعرف أنّ بياناتك لن تتجاوز مجالًا محددًا من القيم، فإن اختيار نوع مستقل عن المعمارية يمكن أن يزيد السرعة ويقلل من استخدام الذاكرة، فإذا كنت تعلم مثلًا أنّ بياناتك لن تتجاوز القيمة 100 وستكون موجبةً فقط، فسيجعل اختيار uint8 برنامجك أكثر كفاءةً لأنه يتطلب ذاكرةً أقل.

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

الفرق الطفحان والالتفاف Overflow vs Wraparound

تتعامل جو مع حالة الطفحان overflow أو بلوغ الحد الأعظمي wraparound عند محاولة تخزين قيمة أكبر من نوع البيانات المصمم لتخزينه اعتمادًا على ما إذا كانت القيمة محسوبة في وقت التصريف compile time أو في وقت التشغيل runtime، إذ يحدث خطأ في وقت التصريف عندما يعثر البرنامج على خطأ أثناء محاولته إنشاء البرنامج؛ أما الخطأ في وقت التشغيل، فيحدث بعد تصريف البرنامج أثناء تنفيذه بالفعل.

ضبطنا قيمة المتغير maxUint32 في المثال التالي إلى أعلى قيمة ممكنة:

package main

import "fmt"

func main() {
    var maxUint32 uint32 = 4294967295 // Max uint32 size
    fmt.Println(maxUint32)
}

سيكون الخرج:

Output4294967295

إذا أضفنا العدد 1 إلى المتغير maxUint32 في وقت التشغيل، فسيحدث التفاف إلى القيمة 0، أي سيكون الخرج:

0

سنعدِّل الآن البرنامج ونضيف العدد 1 إلى المتغير maxUint32 قبل وقت التصريف:

package main

import "fmt"

func main() {
    var maxUint32 uint32 = 4294967295 + 1
    fmt.Println(maxUint32)

}

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

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

prog.go:6:36: constant 4294967296 overflows uint32

ومعرفة أحجام بياناتك وما تتعامل معه يساعد على تجنب أخطاء الطفحان تلك في برنامجك مستقبلًا لذا يجب الانتباه!

ستتعرّف الآن على كيفية تخزين القيم المنطقية أو البوليانية boolean.

القيم المنطقية

يمتلك نوع البيانات المنطقية قيمتين؛ إما صح true أو خطأ false، وتعرَّف على أنها من النوع bool عند التصريح عنها، كما تُستخدَم القيم المنطقية لتمثيل قيم الحقيقة المرتبطة بالجبر المنطقي في الرياضيات والذي يُعلم الخوارزميات في علوم الحاسوب، كما يُعبَّر عن القيمتَين true و false في جو بمحرفين صغيرين دائمًا وهما t و f على التوالي.

تُعطينا العديد من العمليات الحسابية إجابات يتم تُقيَّم إما بصح أو خطأ مثل:

• أكبر من: 500 > 100 إجابتها true أو 1 > 5 إجابتها false.
• أقل من: 200 < 400 true أو 4 < 2 false.
• يساوي: 5 = 5 true أو 500 = 400 false.

يمكنك تخزين قيمة منطقية في متغير بالصورة التالية:

myBool := 5 > 8

ثم يمكنك طباعتها من خلال الدالة ()fmt.Println كما يلي:

fmt.Println(myBool)

بما أن العدد 5 ليس أكبر من 8، فسنحصل على الخرج التالي:

false

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

السلاسل النصية Strings

تُعَدّ السلسلة النصية سلسلةً من محرف (حرف أبجدي أو عدد أو رمز) واحد أو أكثر، ويمكن أن تكون سلسلة ثابتة أو متغيرة.

يوجد صياغتان لتعريف السلاسل النصية في جو، فإذا استخدمت علامتَي الاقتباس الخلفية ``` لتمثيل السلسلة بداخلها، فهذا يعني أنك ستُنشئ سلسلةً أوليّةً raw string literal؛ أما إذا استخدمت علامتَي الاقتباس المزدوجة "، فهذا يعني أنك ستُنشئ سلسلةً مُفسّرةً interpreted string literal.

السلسلة النصية الأولية

هي تسلسل من المحارف بين علامتَي اقتباس خلفية ````` وتُسمى أيضًا علامتَي التجزئة الخلفية back ticks.

سيُعرض كل شيء داخل هاتين العلامتين كما هو، وهذا لا يشمل علامتَي الاقتباس، فهما مجرد دليل لنقطة بداية ونهاية السلسلة مثل:

a := `Say "hello" to Go!`
fmt.Println(a)

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

Say "hello" to Go!

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

a := `Say "hello" to Go!\n`
fmt.Println(a)

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

Say "hello" to Go!\n

لاحظ أنّ السلسلة النصية السابقة هي سلسلة أوليّة، أي غير مُفسّرة، وبالتالي تُعرَض كما هي ولن يكون للرمز n\ أيّ معنى خاص.

تُستخدَم السلاسل الأولية أيضًا لإنشاء سلاسل متعددة الأسطر:

a := `This string is on
multiple lines
within a single back
quote on either side.`
fmt.Println(a)

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

This string is on
multiple lines
within a single back
quote on either side.

لاحظ هنا تأثير السلاسل الأولية؛ إذ ذكرنا سابقًا أنها تطبع السلسلة كما هي.

السلسلة النصية المفسرة

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

a := "Say \"hello\" to Go!"
fmt.Println(a)

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

Say "hello" to Go!

ستستخدِم غالبًا السلاسل المُفسرة لأنها تتعامل مع المحارف الخاصة وتسمح بتخطيها أيضًا وبالتالي تملك تحكمًأ أكبر.

سلاسل صيغة التحويل الموحد UTF-8

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

يدعم جو صيغة التحويل هذه دون أي إعداد خاص أو مكتبات أو حزم، ويمكن تمثيل الأحرف الرومانية مثل الحرف A بقيمة ASCII مثل الرقم 65، لكن سيكون ترميز UTF-8 للمحارف الخاصة مثل المحرف 世 مطلوبًا، كما يستخدِم جو النوع رون لبيانات UTF-8.

a := "Hello, 世界"

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

package main

import "fmt"

func main() {
    a := "Hello, 世界"
    for i, c := range a {
        fmt.Printf("%d: %s\n", i, string(c))
    }
    fmt.Println("length of 'Hello, 世界': ", len(a))
}

عرّفنا المتغير a في المثال السابق وأسندنا إليه السلسة النصية Hello, 世界 التي تحتوي على محارف UTF-8، ثم استخدمنا حلقة for مع الكلمة المفتاحية range للتكرار على محارف السلسلة، إذ تُفهرس الكلمة المفتاحية range عناصر السلسلة المحددة وتعيد قيمتين الأولى هي فهرس البايت والثانية هي قيمة البايت ا-لتي تمثِّل هنا محرف السلسلة- وبترتيب ورودها نفسه في السلسلة.

تُستخدَم الدالة fmt.Printf كما هي العادة من أجل الطباعة على الشاشة، حيث حددنا لها التنسيق بالصورة d: %s\n%، إذ تشير d% إلى وجود عدد صحيح مكانها وهو الفهرس i الذي مثّل المُعطى الثاني للدالة، والرمز s% إلى وجود سلسلة نصية أو محرف وهو المحرف c المُمثّل بالمُعطى الثالث والرمز الأخير للانتقال إلى سطر جديد، ولاحظ أيضًا أننا وضعنا c ضمن الدالة string وذلك لكي تعامل معاملة سلسلة، ثم طبعنا أخيرًا طول المتغير a من خلال استخدام الدالة len.

كما ذكرنا سابقُا؛ الرون هو اسم بديل للنوع int32 ويمكن أن يتكون من واحد إلى أربعة بايت، إذ يُستخدم 3 بايتات لتمثيل المحرف 世 والكلمة المفتاحية range تُدرك ذلك، وبالتالي عندما تصل إليه تقرأ 3 بايتات متتالية على أنها فهرس لمحرف واحد وهذا واضح من الخرج التالي.

0: H
1: e
2: l
3: l
4: o
5: ,
6:
7: 世
10: 界
length of 'Hello, 世界':  13

لاحظ أنه عند طباعة الطول حصلنا على 13، بينما عدد الفهارس هو 8 وهذا يُفسّر ماذكرناه في الأعلى.

لن تعمل دائمًا مع سلاسل UTF-8، ولكن عندما تعمل معها ستكون مُدركًا لسبب تمثيلها باستخدام النوع رون الذي يمكن أن يكون طوله من 8 إلى 32 بت وليس int32 واحدة فقط.

التصريح عن أنواع البيانات للمتغيرات

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

يمكننا تحديد متغير باستخدام الكلمة المفتاحية var متبوعة باسم المتغير ونوع البيانات المطلوب، إذ سنصرّح في المثال التالي عن متغير يسمى pi من النوع float64، أي الكلمة المفتاحية var هي أول ما يُكتب عند التصريح عن متغير، ثم اسم المتغير ثم نوع البيانات:

var pi float64

يمكن إسناد قيمة ابتدائية للمتغير اختياريًا:

var pi float64 = 3.14

تُعَدّ جو لغةً ثابتة الأنواع statically-typed language مثل لغة C و Java و ++C، وهذا يعني أن كل تعليمة في البرنامج تُفحَص في وقت التصريف، كما يعني أيضًا أنّ نوع البيانات مرتبط بالمتغير؛ أما في اللغات ديناميكية الأنواع مثل بايثون أو PHP، فيرتبط نوع البيانات بالقيمة، فقد يُصرَّح مثلًا عن نوع البيانات في جو عند التصريح عن المتغير كما يلي:

var pi float64 = 3.14
var week int = 7

يمكن أن يكون كل من هذه المتغيرات نوع بيانات مختلف إذا عرّفته بطريقة مختلفة، لكن بعد التصريح عنه لأول مرة لن تكون قادرًا على تغيير ذلك؛ أما في لغة PHP فالأمر مختلف، إذ يرتبط نوع البيانات بالقيمة كما يلي:

$s = "sammy";         // يأخذ المتغير ديناميكًا نوع سلسلة نصية
$s = 123;             // يأخذ المتغير ديناميكيًا نوع عدد صحيح

كان المتغير s سلسلةً نصيةً ثم تغيَّر إلى عدد صحيح اوتوماتيكيًا تبعًا للقيمة المُسندة إليه.

سنتعرّف الآن على أنواع البيانات الأكثر تعقيدًا مثل المصفوفات.

المصفوفات Arrays

تُعَدّ المصفوفة متغيرًا واحدًا يتألف من تسلسل مرتب من العناصر ذات النوع نفسه، وكل عنصر في المصفوفة يمكن تخزين قيمة واحدة فيه. عناصر المصفوفة تتميز عن بعضها من خلال رقم محدد يعطى لكل عنصر يسمى فهرس index، وأول عنصر في المصفوفة دائمًا يكون فهرسه 0.

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

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

تُعرّف المصفوفات من خلال التصريح عن حجمها ثم نوع البيانات ثم القيم المحددة بين الأقواس المعقوصة {}.

[capacity]data_type{element_values}

مثال:

[3]string{"blue coral", "staghorn coral", "pillar coral"}

يمكنك إسناد المصفوفة إلى متغير ثم طباعتها كما يلي:

coral := [3]string{"blue coral", "staghorn coral", "pillar coral"}
fmt.Println(coral)

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

[blue coral staghorn coral pillar coral]

الشرائح Slices

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

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

يُصرّح عن الشرائح من خلال تحديد نوع البيانات مسبوقًا بقوس فتح وإغلاق مربع [] والقيم بين أقواس معقوصة {}، وفيما يلي مثالًا عن شريحة من الأعداد الصحيحة:

[]int{-3, -2, -1, 0, 1, 2, 3}

شريحة من الأعداد الحقيقية:

[]float64{3.14, 9.23, 111.11, 312.12, 1.05}

شريحة من السلاسل النصية:

[]string{"shark", "cuttlefish", "squid", "mantis shrimp"}

يمكنك أيضًا إسنادها إلى متغير:

seaCreatures := []string{"shark", "cuttlefish", "squid", "mantis shrimp"}

ثم طباعة هذا المتغير:

fmt.Println(seaCreatures)

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

[shark cuttlefish squid mantis shrimp]

يمكنك استخدام الكلمة المفتاحية append لإضافة عنصر جديد إلى الشريحة، وسنضيف السلسلة seahorse إلى الشريحة السابقة على سبيل المثال كما يلي:

seaCreatures = append(seaCreatures, "seahorse")

سنطبع الشريحة الآن للتأكد من نجاح العملية:

fmt.Println(seaCreatures)

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

[shark cuttlefish squid mantis shrimp seahorse]

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

الخرائط Maps

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

تُنشأ الخرائط باستخدام الكلمة المفتاحية map متبوعة بنوع بيانات المفاتيح بين قوسين معقوفين [] متبوعًا بنوع بيانات القيم، ثم أزواج القيم والمفاتيح في أقواس معقوصة.

map[key]value{}

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

map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}

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

سنخزّن الخريطة أعلاه ضمن متغير ثم سنطبعها:

sammy := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}
fmt.Println(sammy)

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

map[animal:shark color:blue location:ocean name:Sammy]

إذا أردت الوصول إلى لون سامي sammy وطباعته فيمكنك كتابة ما يلي:

fmt.Println(sammy["color"])

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

blue

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

خاتمة

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

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

اقرأ أيضًا

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

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

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

صياغة التعليقات

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

// This is a comment
// هذا تعليق على الشيفرة

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

package main

import (
    "fmt"
)

func main() {
    // ‫اطبع العبارة "Hello, World!‎" إلى الطرفية
    fmt.Println("Hello, World!")
}

مثال آخر لوضع التعليقات ضمن حلقة for التي تُكرِّر تنفيذ كتلة برمجية أو مجموعة من التعليمات البرمجية:

package main

import (
    "fmt"
)

func main() {
    // عرف المتغير التالي على أنه شريحة من سلاسل نصية
    sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}

    // حلقة تكرار للمرور على كل عنصر من عناصر القائمة وطباعته
    for _, shark := range sharks {
        fmt.Println(shark)
    }
}

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

لاحظ على سبيل المثال كيف سنُعلّق على الدالة main، ولاحظ كيف سنضع التعليقات بما يتماشى مع كل مقطع مسبوق بمسافة بادئة:

package main

import "fmt"

const favColor string = "blue"

func main() {
    var guess string
    // إنشاء حلقة تكرار
    for {
        // اطلب من المستخدم تخمين لوني المفضل
        fmt.Println("Guess my favorite color:")
        // اقرأ ما أدخله المستخدم واطبع النتيجة
        if _, err := fmt.Scanln(&guess); err != nil {
            fmt.Printf("%s\n", err)
            return
        }
        // تأكد إن خمن اللون الصحيح
        if favColor == guess {
            // اللون الذي أدخله صحيح
            fmt.Printf("%q is my favorite color!\n", favColor)
            return
        }
        // اللون الذي أدخله خطأ ونطلب منه تكرار الإجابة
        fmt.Printf("Sorry, %q is not my favorite color. Guess again.\n", guess)
    }
}

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

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

التعليقات الكتلية

يمكن استخدام التعليقات الكتليّة Block Comments -أي عدة أسطر من التعليقات- لتوضيح الشيفرات البرمجية المعقدة التي تتوقع بأن لا يكون القارئ على دراية بها، إذ تنطبق هذه التعليقات الطويلة على جزء من الشيفرة أو جميعها، كما توضع في نفس مستوى المسافة البادئة للشيفرة، كما يمكن كتابة التعليقات الكتلية بطريقتين؛ الأولى من خلال المحرفَين السابقَين // وتكرارهما من أجل كل سطر مثل:

// First line of a block comment
// Second line of a block comment

أما الطريقة الثانية، فمن خلال علامة الفتح */ التي نضعها في بداية التعليق وعلامة الإغلاق */ التي نضعها في نهاية التعليق، إذ يُستخدَم // عادةً مع عمليات التوثيق؛ أما /* ... */ لتصحيح الأخطاء debugging.

/*
تعليق طويل
يمتد على
أكثر من سطر
*/

سنستخدم التعليقات الكتليّة في المثال التالي لتوضيح الدالة ()MustGet:

// ‫تأخذ الدالة MustGet رابطًا وتعيد الصفحة الرئيسية له
// وإن حصل أي خطأ ستظهره
func MustGet(url string) string {
    resp, err := http.Get(url)
    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()
    var body []byte
    if body, err = ioutil.ReadAll(resp.Body); err != nil {
        panic(err)
    }
    return string(body)
}

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

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

التعليقات السطرية

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

[code]  // تعليق سطري يشرح سطر الشيفرة

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

z := x % 2  // ‫ احصل على باقي قسمة العدد x

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

x := 8  // إسناد قيمة للعدد

يجب استخدام التعليقات السطرية عند الضرورة وعندما توفِّر إرشادات مفيدةً للشخص الذي يقرأ البرنامج.

تعليق جزء من الشيفرة بدواعي الاختبار والتنقيح

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

يمكن أن يتيح لك استخدام الرمزين /*...*/ تجربة بدائل أخرى أثناء إعداد الشيفرة أو للتعليق على التعليمات البرمجية التي تفشل أثناء استمرار العمل على أجزاء أخرى من التعليمات البرمجية الخاصة بك.

// دالة تضيف عددين
func addTwoNumbers(x, y int) int {
    sum := x + y
    return sum
}

// دالة تضرب عددين
func multiplyTwoNumbers(x, y int) int {
    product := x * y
    return product
}

func main() {
    /*
        ‫علقنا في هذا المقال استدعاء الدالة addTwoNumbers
        لأنه يولد خطأ لم نكتشفه فلا نريد إيقاف الشيفرة

        a := addTwoNumbers(3, 5)
        fmt.Println(a)

    */

    m := multiplyTwoNumbers(5, 9)
    fmt.Println(m)
}

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

خاتمة

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

سيسمح لك التعليق الصحيح على الشيفرة في جو باستخدام الأداة Godoc، وهي أداة تستخرِج التعليقات من التعليمات البرمجية الخاصة بك وتُنشئ وثائق لبرنامج جو الخاص بك.

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

اقرأ أيضًا

• المقال السابق: التعرف على GOPATH في لغة جو Go
• الدليل السريع إلى لغة البرمجة Go
• بناء خادم بروتوكول التحكم في الإرسال TCP متزامن في لغة البرمجة Go

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

تُعَدّ مساحة عمل جو Go Workspace الطريقة التي يدير بها جو ملفات المصدر والملفات الثنائية والكائنات المخزنة مؤقتًا التي ستُستخدَم في وقت لاحق لعمليات التصريف السريع، وعادةً ما تكون لديك مساحة عمل واحدة فقط، إذ من الممكن أن تكون لديك أكثر لكن يُستحسن واحدة فقط، كما يكون GOPATH هو مجلد الجذر لها.

انتبه إلى أنه بدءًا من الإصدار 1.13 أضاف مطوروا لغة Go آلية جديدة لإدارة المكتبات التي يعتمد عليها مشروع مكتوب بلغة جو تدعى وحدات جو Go Modules -سنتحدث عنها لاحقًا- وأصبحت هذه الآلية الطريقة المعتمد حاليًا في إضافة إعتماديات المشروع وإدارة هيكلة مجلده الرئيسي، وصحيح أن هذه الآلية قد حلت مكان GOPATH إلا أنه من الجيد فهم الآلية القديمة هذه التي قد تكون مستعملة في مشاريع قديمة أو تمر معك في شيفرة ما، ولمزيد من التفاصيل ومعرفة أحدث المستجدات عد إلى توثيق workspaces الرسمي من لغة جو.

ضبط متغير البيئة GOPATH$

يحمل متغير البيئة GOPATH$ قائمةً تتضمن أماكن ليبحث فيها جو عن مساحات العمل.

يتوقع جو في الحالة الافتراضية أنّ موقع GOPATH الخاص بك هو HOME/go$، حيث HOME$ هو المجلد الجذر لحساب المستخدِم الخاص بك على الحاسب، ويمكنك تغيير ذلك من خلال تعديل متغير البيئة GOPATH$ حسب توثيق جو.

الفرق بين GOPATH$ و GOROOT$

يُعَدّ GOROOT$ المكان الذي تتواجد فيه شيفرة جو والمصرِّف compiler والأدوات الأخرى التابعة له، أي أنه لا يتضمن الشيفرة المصدرية الخاصة بك، وعادةً ما يكون مسار GOROOT$ هو usr/local/go/ ومسار GOPATH$ هو HOME/go$، كما تجدر الإشارة إلى أنك لست بحاجة إلى إعداد المتغير GOROOT$ بعد الآن، إذ كان ذلك مطلبًا في السابق.

مكونات مساحة العمل

توجد ثلاثة مجلدات داخل مساحة عمل جو أو GOPATH وهي bin و pkg و src، كما يملك كل مجلد من هذه المجلدات وظيفةً خاصةً في جو.

.
├── bin
├── pkg
└── src
  └── github.com/foo/bar
    └── bar.go

يمثّل المجلد GOPATH/bin$ المكان الذي توضع فيه الملفات الثنائية (التنفيذيّة) التي تم تثبيتها بواسطة الأمر go install.

يستخدِم نظام التشغيل متغير البيئة PATH$ للعثور على الملفات الثنائية التي يمكن تنفيذها بدون كتابة المسار الكامل، لذا يوصى بإضافة المجلد bin إلى المتغير PATH$ العام، فإذا لم تضف GOPATH/bin$ مثلًا إلى متغير البيئة PATH$، فسنحتاج إلى كتابة ما يلي:

$ $GOPATH/bin/myapp

أما إذا كان مُضافًا إليه لكان بالإمكان تشغيله بكتابة ما يلي:

$ myapp

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

توضع في المجلد src شيفرة جو المصدرية وهي الملفات التي يتم كتابتها وإنشاؤها باستخدام لغة جو والتي تكون لاحقتها ‎.go، الملفات المصدرية يستخدمها مُصرّف جو لإنشاء ملفات قابلة للتنفيذ (ملفات ثنائية يمكن تشغيلها على نظامك لتنفيذ المهام التي تتضمنها). وانتبه جيدًا مرةً أخرى إلى أنّ هذه الملفات ليست الملفات الموجودة في GOROOT$، كما ستوضع هذه الملفات في المسار GOPATH/src/path/to/code$ أثناء كتابة برامج وحزم ومكتبات جو.

ما هي الحزم؟

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

تتبع جو القواعد التالية في كيفية تقسيم برنامج إلى حزم:

• تُخزّن الحزم مع جميع ملفات جو المصدرية المكتوبة من قبل المستخدِم ضمن المجلد GOPATH/src$.
• الحزمة غالبًا عبارة عن مجلد داخل مشروعك به الملفات التي تحمل اسم الحزمة.
• لابد من وجود حزمة واحدة على الأقل في أي برنامج أو مكتبة.
• إذا كان البرنامج عبارة عن برنامج تنفيذي (وليس مكتبة - library) فإنه يجب وجود حزمة باسم main (أي package main) تكون هي مدخل البرنامج كما رأينا سابقًا.

وكتذكير لما ذكرناه سابقًا:

• لابد لكل ملف شفرة برمجية في Go أن ينتمي إلى حزمة (package) ما.
• لابد لكل حزمة في Go أن تنتمي إلى مجلد ما.
• لا يمكن لحزمتين التواجد على مستوى نفس المجلد، لكن يمكن لعدة ملفات أن تنتمي إلى نفس الحزمة (يعني مجلد به عدة ملفات).
• يمكن أن تتواجد حزمة داخل حزمة أخرى لكن كلٌ في مجلد فرعي على حِدى.
• يمكن للمجلد الرئيسي لمشروعك أن يحتوي على حزمة ما، واحدة فقط، باقي الحزم الخاصة به يمكنها أن تتواجد في مجلدات فرعية.
• غياب حزمة main من برنامج ما، يجعل منه مكتبة فقط وليس برنامجا تشغيليا قائما بحد ذاته.

إذا كانت الشيفرة الخاصة بك موجودةً في المسار GOPATH/src/blue/red$ فيجب أن يكون اسم الحزمة التي تنتمي إليها الشيفرة هو red، ويمكنك استيراد هذه الحزمة كما يلي:

import "blue/red"

في حالة الحزم المتواجدة ضمن مستودعات على مواقع استضافة الشيفرات مثل GitHub و BitBucket، فيجب تضمين المسار الكامل في عملية الاستيراد، فإذا أردنا استيراد الشيفرة المصدرية من الرابط https://github.com/gobuffalo/buffalo، فسنكتب ما يلي:

import "github.com/gobuffalo/buffalo"

وستُخزَّن في الموقع التالي على القرص:

$GOPATH/src/github.com/gobuffalo/buffalo

خاتمة

تعرّفت في هذه المقالة على المجلد GOPATH الذي يحتوي على مجموعة من المجلدات التي يتوقع جو وجود الشيفرة المصدرية الخاصة بك بداخلها، بالإضافة إلى ماهية تلك المجلدات وما تحتوي عليها، كما تعرّفت على كيفية تغيير الموقع الافتراضي HOME/go$ له، وتعرّفت على الآلية التي يبحث بها جو عن الحزم داخل بنية المجلد.

قُدّمت Go Modules في الإصدار 1.11 من جو، وتهدف إلى استبدال مساحات عمل جو و GOPATH، وعلى الرغم من أنه يُوصى ببدء استخدامها إلا أنّ بعض البيئات قد لا تكون جاهزةً لاستخدامها مثل بيئات الشركة corporate environments.

يُعَدّ GOPATH أكثر الجوانب تعقيدًا في إعداد جو ولكن بمجرد إعداده يمكنك نسيانه بعدها على الغالب.

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

اقرأ أيضًا

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

ستتعلم في هذه المقالة كيفية كتابة برنامج بسيط باستخدام لغة جو، إذ سنحاول اتباع العادة التي جرت عليها دروس تعلم لغات البرمجة، وهي ببساطة كتابة جملة "Hello, World!‎" أي "أهلًا بالعالم!"، لكن سنجعل الأمور أكثر متعةً من خلال جعل البرنامج يسأل المستخدِم عن اسمه لكي يطبع الاسم بجانب عبارة الترحيب، وبعد الانتهاء من كتابة البرنامج سيكون خرج البرنامج مشابهًا للخرج التالي:

Please enter your name.
Sammy
Hello, Sammy! I'm Go!

المتطلبات

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

• تثبيت لغة جو وإعداد بيئة برمجة محلية على أبونتو.
• تثبيت لغة جو وإعداد بيئة برمجة محلية على نظام ماك macOS.
• تثبيت لغة جو وإعداد بيئة برمجة محلية على ويندوز.

الخطوة 1 - كتابة برنامج "Hello, World!‎" الأساسي

افتح محرر نصوص سطر الأوامر مثل نانو nano وانشئ ملفًا جديدًا:

$ nano hello.go

اكتب البرنامج التالي بعد فتح الملف النصي في الطرفية:

package main

import "fmt"

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

مكونات الشيفرة:

• الحزمة package: هي كلمة مفتاحية keyword في جو تحدِّد اسم الحزمة التي ينتمي لها هذا الملف، أي الملف الذي تكتب فيه البرنامج، إذ لا بدّ أن يكون لكل ملف حزمة ما، ولا بدّ أن تنتمي كل حزمة في جو إلى مجلد ما، كما لا يمكن لحزمتَين التواجد على مستوى نفس المجلد، لكن يمكن لعدة ملفات أن تنتمي إلى نفس الحزمة (يعني مجلد به عدة ملفات)، كما يمكن أن تتواجد حزمة داخل حزمة أخرى لكن كلٌ في مجلد فرعي على حِدى. في مثالنا السابق، أعطينا main كاسم لحزمتنا، وهو اسم خاص، حيث يُعامل مُصرّف compiler لغة جو هذه الحزمة على أنها مدخل البرنامج، أي أن التعليمات الموجودة في هذه الحزمة يتم تشغيلها أولًا. أسبقنا اسم الحزمة بالكلمة المفتاحية package.
• import كلمة مفتاحية أخرى وتعني استرِد أو اجلِب المكتبة الفلانية أو الحزمة الفلانية.
• fmt اختصار format أو formatting وهي مكتبة قياسية standard library تأتي مع جو، وهي خاصة ببناء وطباعة النص. لاحظ أن اسم المكتبات أو الحزم المُراد استيرادها دائما ما يتم إحاطتها بعلامة اقتباس "".
• في التعبير fmt.Println استعملنا دالة Println من الحزمة fmt التي استوردناها، ولاستعمال أيّ حزمة في جو يكفي كتابة اسمها ثم نقطة ثم اسم الدالة التي تريد استعمالها، وهنا أردنا طباعة نص "Hello, World!‎"، لذا لاحظ أننا مررنا القيمة بين علامتَي اقتباس "" ﻷنها سلسلة نصية string.

احفظ الملف البرمجي الذي أنشأته واخرج من المحرر عن طريق كتابة CTRL + X وتأكيد الخروج بالضغط على المفتاح Y عندما يطلب منك، ويمكنك الآن تجربة برنامجك.

الخطوة 2 - تشغيل البرنامج

يمكنك تشغيل أيّ برنامج مكتوب بلغة جو من خلال كتابة الكلمة المفتاحية go متبوعة باسم الملف، وبالتالي لتشغيل البرنامج السابقة سنكتب:

$ go run hello.go

الخرج:

Hello, World!

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

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

تُنفَّذ الشيفرة أو البرنامج بعد انتهاء عملية التصريف من خلال وضع الدالة ()main في الحزمة main، والتي تتضمن طباعة السلسلة النصية "Hello, World!‎" عن طريق استدعاء دالة fmt.Println أي ("!fmt.Println("Hello, World، وتُدعى السلسلة النصية وسيطًا لتلك الدالة بما أنها تُمرَّر إليها.

ملاحظة: لا تُطبَع علامتَا الاقتباس الموجودتان على جانبي Hello, World!‎ على الشاشة لأنك تستخدمهما لإخبار جو من أين تبدأ السلسلة الخاصة بك وأين تنتهي.

ستستكشف في الخطوة التالية كيفية جعل البرنامج تفاعليًّا أكثر.

الخطوة 3 - إدخال معلومات من المستخدم لاستخدامها في البرنامج

سيطبع البرنامج السابق الخرج نفسه في كل مرة تستدعيه بها، كما يمكنك إضافة بعض التعليمات إلى البرنامج بحيث تجعله يطلب من المستخدِم إدخال اسمه لكي يُطبع بجانب عبارة الترحيب.

بإمكانك تعديل برنامجك السابق، ولكن يُفضَّل أن تُنشئ برنامجًا جديدًا يسمى greeting.go باستخدام المحرِّر نانو:

nano greeting.go

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

package main

import (
    "fmt"
)

func main() {
  fmt.Println("Please enter your name.")
}

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

أضف الآن السطرvar name string لتخزين مُدخلات المستخدِم:

package main

import (
    "fmt"
)

func main() {
  fmt.Println("Please enter your name.")
  var name string
}

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

أضف الآن السطر fmt.Scanln(&name)‎ إلى الشيفرة:

package main

import (
    "fmt"
)

func main() {
  fmt.Println("Please enter your name.")
  var name string
  fmt.Scanln(&name)
}

يخبر التابع fmt.Scanln الحاسب أن ينتظر إدخالًا من لوحة المفاتيح ينتهي بسطر جديد (الضغط على Enter) أو المحرف n\، إذ توقف عملية الإدخال هذه البرنامج مؤقتًا إلى حين انتهاء المستخدِم من إدخال أيّ نص يريده، ثم يستمر البرنامج عندما يضغط المستخدم على مفتاح الإدخال ENTER من لوحة المفاتيح، إذ تُلتقط بعد ذلك كافة ضغطات المفاتيح بما في ذلك ضغطات المفتاح ENTER وتُحوّل إلى سلسلة من المحارف.

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

أخيرًا، أضف السطر fmt.Printf("Hi, %s! I'm Go!", name)‎ إلى برنامجك لطباعة الخرج:

package main

import (
    "fmt"
)

func main() {
  fmt.Println("Please enter your name.")
  var name string
  fmt.Scanln(&name)
  fmt.Printf("Hi, %s! I'm Go!", name)
}

استخدمنا هذه المرة الدالة fmt.Printf في عملية الطباعة ﻷنها ستسمح لنا بتنسيق عملية الطباعة بالطريقة التي نريدها، إذ تأخذ هذه الدالة وسيطَين الأول هو سلسلة نصية تتضمن العنصر النائب s% (العنصر النائب Placeholder هو متغير يأخذ قيمة في وقتٍ لاحق أي ينوب عن القيمة الحقيقة في البداية)، والثاني هو المُتغير الذي سيُحقن في هذا العنصر النائب، وهذه الدالة تُسمى دالة مرنة، أي تأخذ عددًا غير مُحدد من المعطيات، كما أن المُعطى الأول قد يتضمن أكثر من عنصر نائب لكن هذا لايهمنا الآن، ونفعل ذلك لأن لغة جو لا تدعم تضمين المتغيرات ضمن السلاسل النصية مباشرة كما تفعل لغات أخرى مثل لغة جافاسكربت.

احفظ الملف البرمجي الذي أنشأته واخرج من المحرِّر عن طريق الضغط على CTRL + X وتأكيد الخروج بالضغط على المفتاح Y عندما يطلب منك.

شغّل البرنامج الآن وستُطالب بإدخال اسمك، لذا أدخله واضغط على ENTER، وقد لا يكون الخرج هو بالضبط ما تتوقعه:

Please enter your name.
Sammy
Hi, Sammy
! I'm Go!

بدلًا من طباعة Hi, Sammy! I'm Go!‎، هناك سطر فاصل بعد الاسم مباشرةً، إذ التقط البرنامج جميع ضغطات المفاتيح بما في ذلك المفتاح ENTER الذي ضغطنا عليه لإخبار البرنامج بالمتابعة، لذا تكمن المشكلة في السلسلة، إذ يؤدي الضغط على المفتاح الإدخال ENTER إلى إنشاء رمز خاص يُنشئ سطرًا جديدًا وهو الرمز n\.

افتح الملف لإصلاح المشكلة:

$ nano greeting.go

أضف السطر التالي:

...
fmt.Scanln(&name)
...

ثم السطر التالي:

name = strings.TrimSpace(name)

استخدمنا هنا الدالة TrimSpace من الحزمة strings في مكتبة جو القياسية على السلسلة التي التقطتها باستخدام fmt.Scanln، إذ تزيل الدالة strings.TrimSpace محارف المسافة space characters بما في ذلك الأسطر الجديدة من بداية السلسلة ونهايتها، إذًا ستُزيل محرف السطر الجديد في نهاية السلسلة التي أُنشِئت عند الضغط على ENTER.

ستحتاج لاستخدام الحزمة strings إلى استيرادها في الجزء العلوي من البرنامج.

ضع ما يلي ضمن البرنامج:

import (
    "fmt"
)

أضف السطر التالي لاستيراد الحزمة strings:

import (
    "fmt"
    "strings"
)

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

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println("Please enter your name.")
    var name string
    fmt.Scanln(&name)
    name = strings.TrimSpace(name)
    fmt.Printf("Hi, %s! I'm Go!", name)
}

احفظ الملف البرمجي الذي أنشأته واخرج من المحرِّر عن طريق الضغط على الاختصار CTRL + X وتأكيد الخروج بالضغط على الزر Y عندما يطلب منك.

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

$ go run greeting.go

ستحصل على الناتج المتوقع هذه المرة بعد إدخال اسمك والضغط على مفتاح ENTER:

Please enter your name.
Sammy
Hi, Sammy! I'm Go!

أصبح لديك الآن برنامج جو يأخذ مدخلات من المستخدِم ويطبعها على الشاشة.

الخاتمة

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

ترجمة -وبتصرُّف- للمقال How To Write Your First Program in Go لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: تثبيت لغة جو وإعداد بيئة برمجة محلية لها على ويندوز
• الدليل السريع إلى لغة البرمجة Go
• بناء خادم بروتوكول التحكم في الإرسال TCP متزامن في لغة البرمجة Go

جو Go هي لغة برمجة حديثة ذات قواعد syntax عالية المستوى على غرار لغات البرمجة النصية مثل بايثون وروبي وجافا سكربت، وقد طوّرتها شركة جوجل Google في عام 2007 لتكون ملائمة لنوعية احتياجات جوجل الحسابية من حيث التصريف compilation السريع وسهولة البرمجة والتنفيذ الفعّال. تعتبر جو لغة بسيطة جدًا من ناحية القواعد، فعدد الكلمات المفتاحية بها والأنواع الأساسية فيها ضئيل مقارنة بباقي اللغات، كما أنها تقلل كثيرًا من فكرة وجود طرق متعددة لتنفيذ مهمة ما، حتى أنها لا تحتوي على حلقة while وتقتصر فقط على حلقة for مما يجعل هذه اللغة سهلة التعلم ومناسبة للمبرمجين الجدد والخبراء ويميّزها عن باقي اللغات. تعالج جو عمليات التزامن بشكل مبتكر، بالإضافة إلى توفير الأدوات اللازمة لبناء ثنائيات محلية native binaries (برامج تنفيذية executables أو مكتبات shared libraries) لاستخدامها في منصات وأماكن أخرى.

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

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

المتطلبات

جهاز مثبت عليه نظام ويندوز 10 مع إمكانية الوصول على أساس مدير والاتصال بالانترنت.

الخطوة 1: فتح وتهيئة PowerShell

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

يُعَدّ PowerShell برنامجًا من مايكروسوفت يوفر واجهةً لصدفة سطر الأوامر، إذ تُنفَّذ المهام الإدارية عن طريق تشغيل أوامر cmdlets أي command-lets، وهي أصناف Classes متخصصة من إطار العمل NET. الذي يمكنه تنفيذ العمليات، وقد أصبح PowerShell مفتوح المصدر في عام 2016، وهو متوفر الآن على أطر العمل لكل من نظامَي ويندوز ويونكس UNIX بما في ذلك ماك Mac ولينكس Linux.

يمكنك النقر بزر الفأرة الأيمن فوق رمز قائمة ابدأ في الزاوية اليسرى السفلية من شاشتك للعثور على PowerShell على جهازك، ثم انقر فوق بحث واكتب PowerShell في شريط البحث، ثم انقر بزر الفأرة الأيمن فوق Windows PowerShell، ولأسباب تتعلق بهذه المقالة يُرجى فتحه على أساس مسؤول -أو مدير- من خلال اختيار Run as Administrator، وعندما ينبثق لك مربع حوار سيسألك هل تريد السماح لهذا التطبيق بإجراء تغييرات على جهاز الكمبيوتر الخاص بك؟ انقر فوق نعم yes، وبعد إجراء ما ذكرناه ستظهر لك النافذة التالية:

انتقل الآن إلى مجلد النظام من خلال الأمر التالي:

$ cd ~

سينقلك تنفيذ هذا الأمر إلى المجلد PS C:\Users\sammy.

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

• المُقيّد Restricted: هي سياسة التنفيذ الافتراضية، وفي هذا الوضع لن تتمكن من تشغيل البرامج النصية scripts، وسيعمل PowerShell فقط على أساس صدفة تفاعلية مع هذه البرامج.
• الموقّع AllSigned: سيمكنك هذا الوضع من تشغيل جميع البرامج النصية وملفات الضبط الموقَّعة عبر التوقيع الرقمي بواسطة ناشر موثوق، مما يعني أنه من المحتمل أن تٌعرِّض جهازك لخطر تشغيل البرامج النصية الضارة التي وقّع عليها ناشر موثوق به.
• الموقّعة عن بعد RemoteSigned: يتيح لك تشغيل البرامج النصية وملفات الضبط المُحمّلة من الإنترنت والموقَّعة من قِبل ناشرين موثوقين، أي أنه يعرّض جهازك للخطر أيضًا إذا كانت هذه البرامج النصية الموثوقة ضارة.
• بدون قيود Unrestricted: ستُشغَّل جميع البرامج النصية وملفات الضبط التي نُزِّلت من الإنترنت عند تأكيدك أنّ الملف قد نُزِّل من الإنترنت، وهنا لا يلزم وجود توقيع رقمي، وبالتالي فإنك تُعرّض جهازك لخطر تشغيل البرامج النصية غير الموقّعة والتي من المحتمل أن تكون ضارةً.

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

نفّذ ما يلي ضمن PowerShell:

$ Set-ExecutionPolicy -Scope CurrentUser

سيطالبك PowerShell بعد ذلك بتقديم سياسة تنفيذ، لذا أدخل ما يلي لاستخدام RemoteSigned:

$ RemoteSigned

سيُطلب منك تأكيد التغيير في سياسة التنفيذ بعد الضغط على ENTER، لذا اكتب المحرف y للسماح بتنفيذ التغييرات، كما يمكنك التأكد من نجاح ذلك من خلال الاستعلام عن الأذونات الحالية كما يلي:

$ Get-ExecutionPolicy -List

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

        Scope ExecutionPolicy
        ----- ---------------
MachinePolicy       Undefined
   UserPolicy       Undefined
      Process       Undefined
  CurrentUser    RemoteSigned
 LocalMachine       Undefined

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

الخطوة 2 - تثبيت مدير الحزم شوكولاتي Chocolatey

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

يُعَدّ شوكولاتي Chocolatey مدير حزم يمكن التفاعل معه من خلال سطر أوامر ومُصمَّم لنظام التشغيل ويندوز ويعمل مثل apt-get على لينكس، كما يُعَدّ برمجية مفتوحة المصدر يساعدك على تثبيت التطبيقات والأدوات بسرعة، وستتعلم في هذه المقالة كيفية استخدامه لتنزيل ما تحتاجه لبيئة التطوير الخاصة بك.

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

ابدأ بإنشاء كائن WebClient اسمه script$ والذي يشارك إعدادات الاتصال بالإنترنت مع Internet Explorer:

$ $script = New-Object Net.WebClient

ألق نظرةً على الخيارات المتاحة عن طريق تمرير كائن script$ مع المحرف | إلى الصنف Get-Member:

$ $script | Get-Member

سيؤدي ذلك إلى عرض جميع الأعضاء -أي الخصائص والدوال- الخاصة بالكائن WebClient:

 . . .
[secondary_label Snippet of Output]
DownloadFileAsync         Method  void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur...
DownloadFileTaskAsync     Method  System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa...
DownloadString            Method  string DownloadString(string address), string DownloadString(uri address) #method we will use
DownloadStringAsync       Method  void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy...
DownloadStringTaskAsync   Method     System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy…
 . . .

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

$ $script.DownloadString("https://chocolatey.org/install.ps1")

ثبّت شوكولاتي بعد فحص البرنامج النصي بكتابة ما يلي في PowerShell:

$ iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex

يسمح لك أمر iwr -وهو أحد أوامر cmdlet- أو Invoke-WebRequest باستخراج البيانات من الويب، إذ سيؤدي ذلك إلى تمرير البرنامج النصي إلى iex، أو Invoke-Expression cmdlet، والذي سينفذ محتويات البرنامج النصي ويشغّل عملية تثبيت مدير حزم شوكولاتي.

سيصبح بإمكانك بعد تثبيت شوكولاتي من خلال PowerShell البدء في تثبيت أدوات إضافية باستخدام أمر choco، وإذا كنت بحاجة إلى تحديث شوكولاتي في أيّ وقت في المستقبل، فنفّذ الأمر التالي:

$ choco upgrade chocolatey

يمكنك تثبيت ما تبقى من أدوات لتجهيز بيئة برمجة جو بعد تثبيت مدير الحزم.

الخطوة 3 - تثبيت محرر النصوص Nano (خطوة اختيارية)

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

استخدم شوكولاتي لتثبيت نانو:

$ choco install -y nano

تُستخدَم الراية y- للتأكيد التلقائي -أي الموافقة- على تشغيل البرنامج النصي.

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

الخطوة 4 - تثبيت جو

ستستخدِم شوكولاتي كما في الخطوة السابقة لتثبيت جو:

$ choco install -y golang

ملاحظة: كلمة go عبارة عن كلمة صغيرة وتتطابق مع العديد من الحزم، وبالتالي أصبح من الشائع استخدام كلمة golang على أساس مصطلح لتثبيت الحِزم وعند البحث على الإنترنت عن مقالات متعلقة بلغة جو، وقد وُلِّد مصطلح Golang من رابط الموقع الرسمي لجو وهو golang.org.

سيثبّت PowerShell جو الآن وستشاهد الخرج التالي:

Environment Vars (like PATH) have changed. Close/reopen your shell to
see the changes (or in powershell/cmd.exe just type `refreshenv`).
The install of golang was successful.
 Software installed as 'msi', install location is likely default.

Chocolatey installed 1/1 packages.
See the log for details (C:\ProgramData\chocolatey\logs\chocolatey.log).

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

$ go version

سترى خرجًا مُشابهًا للخرج التالي:

go version go1.12.1 windows/amd643.7.0

حيث يعرض لك تفاصيل النسخة الحالية المثبتة على حاسبك من جو. يمكنك الآن إعداد مساحة عمل لمشاريع التطوير الخاصة بك.

الخطوة 5 - إنشاء مساحة العمل الخاصة بك لبناء مشاريع جو

يمكنك إنشاء مساحة عمل البرمجة الخاصة بك بعد تثبيت شوكولاتي ونانو ولغة جو، إذ ستحتوي مساحة العمل على مجلدَين في جذرها وهما:

• src: مجلد ستوضَع فيه ملفات جو المصدرية وهي الملفات التي المكتوبة والمنشأة باستخدام لغة جو، إذ يستخدِمها مُصرِّف جو لإنشاء ملفات قابلة للتنفيذ وهي ملفات ثنائية يمكن تشغيلها على نظامك لتنفيذ المهام التي تتضمنها).
• bin: مجلد ستوضَع فيه الملفات الثنائية التي أُنشِئت وثبِّتَت بواسطة أدوات جو؛ وبعبارة أخرى هي البرامج التي المصرَّفة بواسطة الشيفرة المصدرية الخاصة بك أو غيرها من التعليمات البرمجية المصدرية المرتبطة بجو والتي قد نزِّلت.

من المحتمل أن يحتوي المجلد الفرعي src على عدة مستودعات للتحكم في الإصدارات مثل Git و Mercurial و Bazaar، وهذا يسمح لك باستيراد أساسي canonical import للشيفرة في مشروعك وهو عملية استيراد تشير إلى حزمة مؤهلة وجاهزة بالكامل مثل github.com/digitalocean/godo.

سترى مجلدات مثل github.com أو golang.org عندما يستورد برنامجك مكتبات خارجية، فإذا كنت تستخدِم -أو لديك- شيفرات برمجية على إحدى المواقع مثل GitHub، فستضع أيضًا هذه المشاريع أو الملفات المصدرية ضمن هذا المجلد وستتعرّف على ذلك بعد قليل.

ستبدو مساحة العمل النموذجية هكذا:

.
├── bin
│   ├── buffalo                                      # أمر تنفيذي
│   ├── dlv                                          # أمر تنفيذي
│   └── packr                                        # أمر تنفيذي
└── src
    └── github.com
        └── digitalocean
            └── godo
                ├── .git                            # البيانات الوصفية لمستودع جيت
                ├── account.go                      # ملف الحزمة
                ├── account_test.go             # اختبار ملف الحزمة
                ├── ...
                ├── timestamp.go
                ├── timestamp_test.go
                └── util
                    ├── droplet.go
                    └── droplet_test.go

يُعَدّ المجلد الافتراضي لمساحة العمل في جو بدءًأ من الإصدار 1.8المجلد الرئيسي home للمستخدِم الذي يحتوي على مجلد فرعي باسم go أي HOME/go$، فإذا كنت تستخدِم إصدارًا أقدم من 1.8، فمن الأفضل الاستمرار في استخدام الموقع HOME/go$ لمساحة عملك.

نفّذ الأمر التالي للانتقال إلى المجلد HOME$:

$ cd $HOME

أنشئ بعدها مجلدًا لبيئة العمل بتنفيذ الأمر التالي:

$ mkdir go/bin, go/src

سيؤدي ذلك إلى إنشاء بنية المجلد التالية:

└── $HOME
    └── go
        ├── bin
        └── src

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

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

$ $env:GOPATH

يجب أن ترى الخرج التالي مع اسم المستخدِم الخاص بك بدلًا من sammy:

C:\Users\sammy\go

عندما يُصرِّف ويثبّت جو الأدوات، فسيضعها في المجلد GOPATH/bin$، وللراحة فإنه من الشائع إضافة المجلد الفرعي bin الخاص بمساحة العمل إلى ‎$PATH، ويمكنك إنجاز ذلك من خلال الأمر setx في PowerShell:

$ setx PATH "$($env:path);$GOPATH\bin"

سيسمح لك ذلك بتشغيل أيّ برامج تصرّفها أو تنزّلها عبر أدوات جو في أيّ مكان على نظامك.

الآن وبعد أن أنشأت المجلد الجذر لمساحة العمل وضبطت مجموعة متغيرات البيئة GOPATH$ الخاصة بك، فقد أصبح بإمكانك إنشاء مشاريعك المستقبلية باستخدام بنية المجلد التالية، ويفترض هذا المثال أنك تستخدِم موقع GitHub لاستضافة مشروعك:

$GOPATH/src/github.com/username/project

إذا كنت تعمل على مشروع https://github.com/digitalocean/godo، فسيُخزَّن في المجلد التالي:

$GOPATH/src/github.com/digitalocean/godo

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

$ go get github.com/digitalocean/godo

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

يمكنك أيضًا التحقق من نجاح عملية التنزيل من خلال سرد محتويات المجلد:

$ ls -l $GOPATH/src/github.com/digitalocean/godo

يجب أن تشاهد خرجًا يشبه الخرج التالي:

    Directory: C:\Users\sammy\go\src\github.com\digitalocean\godo


Mode                LastWriteTime       Length Name
----                -------------       ------ ----
d-----        4/10/2019   2:59 PM             util
-a----        4/10/2019   2:59 PM             9 .gitignore
-a----        4/10/2019   2:59 PM             69 .travis.yml
-a----        4/10/2019   2:59 PM         1592 account.go
-a----        4/10/2019   2:59 PM         1679 account_test.go
-rw-r--r--  1 sammy  staff   2892 Apr  5 15:56 CHANGELOG.md
-rw-r--r--  1 sammy  staff   1851 Apr  5 15:56 CONTRIBUTING.md
.
.
.
-a----        4/10/2019   2:59 PM         5076 vpcs.go
-a----        4/10/2019   2:59 PM         4309 vpcs_test.go

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

الخطوة 6 - إنشاء برنامج بسيط

ستنشئ برنامجًا بسيطًا بلغة جو Go يطبع العبارة “Hello, World!‎” بغية اختبار مساحة العمل والتعرف أكثر على جو، كما ستنشئ هنا ملفًا مصدريًا واحدًا لجو وليس مشروعًا متكاملًا، لذا لا داعي لأن تكون ضمن مساحة العمل الخاصة بك لإنجاز ذلك.

افتح محرر نصوص سطر الأوامر نانو من المجلد الرئيسي وأنشئ ملفًا جديدًا:

$ nano hello.go

اكتب برنامجك في الملف الجديد:

package main

import "fmt"

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

ستستخدم هذه الشيفرة حزمة fmt وستستدعي الدالة Println لطباعة Hello, World!‎ الممررة على أساس وسيط للدالة.

اخرج الآن من المحرر nano بالضغط على مفتاحَيCTRL+ X، وعند مطالبتك بحفظ الملف، اضغط على Y ثم ENTER، ثم شغّل برنامج hello.go الذي أنشأته عند الخروج من nano والعودة إلى الصدَفة:

$ go run hello.go

سترى الخرج التالي:

Hello, World!

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

خاتمة

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

ترجمة -وبتصرَُف- للمقال How To Install Go and Set Up a Local Programming Environment on Windows 10 لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: تثبيت لغة جو وإعداد بيئة برمجة محلية على نظام ماك macOS
• تثبيت لغة جو وإعداد بيئة برمجة محلية على أبونتو
• فهم، تنصيب وتهيئة بيئة عمل لغة البرمجة Go
• بدء العمل مع ويندوز 10

جو Go هي لغة برمجة حديثة ذات قواعد syntax عالية المستوى على غرار لغات البرمجة النصية مثل بايثون وروبي وجافاسكربت، وقد طوّرتها شركة جوجل Google في عام 2007 لتكون ملائمة لنوعية احتياجات جوجل الحسابية من حيث التصريف compilation السريع وسهولة البرمجة والتنفيذ الفعّال. تعتبر جو لغة بسيطة جدًا من ناحية القواعد، فعدد الكلمات المفتاحية بها والأنواع الأساسية فيها ضئيل مقارنة بباقي اللغات، كما أنها تقلل كثيرًا من فكرة وجود طرق متعددة لتنفيذ مهمة ما، حتى أنها لا تحتوي على حلقة while وتقتصر فقط على حلقة for مما يجعل هذه اللغة سهلة التعلم ومناسبة للمبرمجين الجدد والخبراء ويميّزها عن باقي اللغات. تعالج جو عمليات التزامن بشكل مبتكر، بالإضافة إلى توفير الأدوات اللازمة لبناء ثنائيات محلية native binaries (برامج تنفيذية executables أو مكتبات shared libraries) لاستخدامها في منصات وأماكن أخرى.

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

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

المتطلبات

ستحتاج إلى حاسب يعمل بنظام ماك macOS مع إمكانية وصول إدارية administrative access واتصال بالإنترنت.

الخطوة 1 - فتح الطرفية Terminal

سننجز عملية التثبيت والإعداد من خلال سطر الأوامر command line وهو معروف أيضًا باسم الصدَفة shell وهو وسيلة تخاطب مع الحاسوب عبر كتابة الأوامر له والذي يُمكّنك من تعديل وأتمتة العديد من المهام التي تقوم بها على جهاز الحاسوب كل يوم وهو أداة أساسية لمطورِي البرامج.

تُعَدّ طرفية نظام ماك تطبيقًا يمكنك استخدامه للوصول إلى واجهة سطر الأوامر، ومثل أي تطبيق آخر يمكنك العثور عليه بالذهاب إلى Finder ثم الانتقال إلى مجلد التطبيقات Applications ثم إلى مجلد الأدوات المساعدة Utilities، وانقر بعد ذلك نقرًا مزدوجًا فوق أيقونة الطرفية.

يمكنك أيضًا العثور على الطرفية من خلال فتح Spotlight عن طريق الضغط باستمرار على مفتاحَي CMD + SPACE وكتابتها في المربع الذي يظهر.

هناك العديد من الأوامر الخاصة بالطرفية والتي يمكنك تعلّمها من مقال مدخل إلى طرفيّة لينكس Linux Terminal، وبعد فتح تطبيق الطرفية يمكنك تحميل حزمة أدوات المطورXcode وتثبيتها، إذ ستحتاجها لتثبيت جو.

الخطوة 2 - تثبيت Xcode

تُعَدّ Xcode بيئة تطوير متكاملة integrated development environment أو IDE اختصارًا، وتحتوي على أدوات تطوير البرامج لنظام ماك، كما يمكنك التحقق مما إذا كان Xcode مثبتًا بالفعل عن طريق كتابة ما يلي في الطرفية:

$ xcode-select -p

يعني الخرج التالي أنّ Xcode مُثبّت:

/Library/Developer/CommandLineTools

إذا تلقيت خطأً ما، فثبّت Xcode من متجر App Store واضغط على زر قبول الخيارات الافتراضية.

عُد إلى نافذة الطرفية بعد تثبيت Xcode، وبعد ذلك ستحتاج إلى تثبيت تطبيق أدوات سطر الأوامر Command Line Tools الذي يخص Xcode عن طريق كتابة الأمر التالي:

$ xcode-select --install

إلى هنا تكون قد ثبّت كل من Xcode وتطبيق Command Line Tools -أدوات سطر الأوامر الخاص به بالكامل، ويمكنك الآن تثبيت مدير الحزم Homebrew.

الخطوة 3 - تثبيت وإعداد Homebrew

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

يزوِّد Homebrew نظام ماك بنظام إدارة حزمة برمجيات مجانية ومفتوحة المصدر يعمل على تبسيط عملية تثبيت الحزم على نظام ماك، كما يمكنك تثبيته من خلال تنفيذ الأمر التالي في الطرفية:

$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

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

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

فيما يلي بعض الرايات flags المرتبطة بالأمر curl:

• الراية f- أو fail-- تُخبر الطرفية بعدم تقديم مستند HTML عند حدوث أخطاء في الخادم.
• الراية s- أو silent-- تُستخدَم لكتم الأمر curl، أي لن تظهر لك معلومات أثناء عملية التثبيت، وبالتالي لن تُظهِر لك مقياس التقدم، وعند دمج هذه الراية مع الراية S- أوshow-error --، فسيُظهر لك curl رسالة خطأ في حالة الفشل.
• الراية L- أو location curl-- ستُخبِر curl بأنه عليه إعادة طلب العنوان من المكان الجديد في حال أبلغ الخادم عن انتقال الصفحة المطلوبة إلى موقع مختلف.

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

يجب عليك إنشاء أو فتح ملف ‎~/.bash_profile‎ باستخدام محرر نصوص سطر الأوامر nano من خلال الأمر nano:

$ nano ~/.bash_profile

اكتب الأمر التالي بعد فتح الملف في الطرفية:

export PATH=/usr/local/bin:$PATH

اضغط الآن باستمرار على مفتاح CTRL + o لحفظ التغييرات، وعندما يُطلب منك ذلك اضغط على مفتاح RETURN، كما يمكنك الآن الخروج من nano بالضغط على مفتاحي CTRL + x.

نشِّط هذه التغييرات عن طريق تنفيذ الأمر التالي:

$ source ~/.bash_profile

بذلك ستدخل التغييرات التي أجريتها على متغير البيئة PATH حيّز التنفيذ، كما يمكنك التأكد من تثبيت Homebrew بنجاح عن طريق كتابة ما يلي:

$ brew doctor

إذا لم تكن هناك حاجة إلى إجراء عمليات تحديث، فستحصل على الخرج التالي:

Your system is ready to brew.

بالنسبة لعمليات التحديث التي قد تُطالب بها، فربما تكون تحذيرًا لتشغيل أمر آخر مثل brew update، وذلك للتأكد من أنّ تثبيت Homebrew الخاص بك بدوره محدث.

بعد تجهيز Homebrew يمكنك تثبيت جو.

الخطوة 4 - تثبيت جو

يمكنك البحث عن جميع الحزم المتاحة عن طريق Homebrew من خلال الأمر brew search، وهنا ستبحث عن الحزم أو الوحدات المتعلقة بجو:

$ brew search golang

ملاحظة: لم يُستخدم في هذا المقال بحث brew باستخدام كلمة go، أي أننا لم نكتب brew search go لأنه يُعيد عددًا كبيرًا جدًا من النتائج، فكلمة go عبارة عن كلمة صغيرة وتتطابق مع العديد من الحزم، وبالتالي أصبح من الشائع استخدام كلمة golang على أساس مصطلح بحث، كما تُعَدّ هذه ممارسة شائعةً عند البحث على الإنترنت عن مقالات متعلقة بجو أيضًا، وقد وُلِد مصطلح Golang من عنوان موقع اللغة الرسمي golang.org.

سيكون الخرج قائمةً من الحزم والوحدات المتعلقة بلغة جو كما ذكرنا:

golang    golang-migrate

يمكنك الآن تثبيت لغة جو عبر تنفيذ الأمر التالي:

$ brew install golang

ستعطيك الطرفية ملاحظات تتعلق بتثبيت جو، وقد يستغرق التثبيت بضع دقائق قبل اكتمال التثبيت.

اكتب ما يلي للتحقق من إصدار جو الذي ثبّته:

$ go version

سيطبع الأمر السابق الإصدار المُثبت لديك من جو وسيكون الإصدار الحديث والمستقر.

يمكنك لاحقًا تحديث جو من خلال تنفيذ الأوامر التالية لتحديث Homebrew ثم تحديث جو:

$ brew update
$ brew upgrade golang

سيحدِّث الأمر الأول صيغة Homebrew نفسها، وبالتالي ضمان حصولك على أحدث المعلومات للحزم التي تريد تثبيتها؛ أما الأمر الثاني فسيُحدّث الحزمة golang إلى أحدث إصدار متوفر.

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

بعد تثبيت جو أصبحت جاهزًا لإنشاء مساحة عمل لمشاريع جو الخاصة بك.

الخطوة 5 - إنشاء مساحة العمل الخاصة بك لبناء مشاريع جو

الآن يمكنك المتابعة وإنشاء مساحة عمل البرمجة الخاصة بك بعد أن ثبّتََ Xcode و Homebrew و Go.

ستحتوي مساحة العمل على مجلدَين في جذرها:

• src: ستوضع فيه ملفات جو المصدرية، وهي الملفات التي تُكتَب وتُنشأ باستخدام لغة جو، كما يستخدِمها مُصرِّف جو لإنشاء ملفات قابلة للتنفيذ (ملفات ثنائية يمكن تشغيلها على نظامك لتنفيذ المهام التي تتضمنها).
• bin: ستوضع فيه الملفات القابلة للتنفيذ التي أنشئت وثبِّتت بواسطة أدوات جو، وبعبارة أخرى هي البرامج التي تم تصريفها بواسطة الشيفرة المصدرية الخاصة بك أو غيرها من الشيفرة المصدرية المرتبطة بجو والتي جرى تحميلها.

من المحتمل أن يحتوي المجلد src على عدة مستودعات للتحكم في الإصدارات مثل Git و Mercurial و Bazaar، ويسمح لك هذا باستيراد أساسي canonical import للشفرة في مشروعك، إذ يُعَدّ الاستيراد الأساسي عملية استيراد تشير إلى حزمة مؤهلة وجاهزة بالكامل مثل github.com/digitalocean/godo.

سترى مجلدات مثل github.com أو golang.org عندما يستورد برنامجك مكتبات خارجية، فإذا كنت تستخدم -أو لديك- شيفرات برمجية على إحدى المواقع مثل GitHub، فستضع أيضًا هذه المشاريع أو ملفات المصدر ضمن هذا المجلد وستتعرّف على ذلك بعد قليل.

ستبدو مساحة العمل النموذجية كما يلي:

.
├── bin
│   ├── buffalo                                      # أمر تنفيذي
│   ├── dlv                                          # أمر تنفيذي
│   └── packr                                        # أمر تنفيذي
└── src
    └── github.com
        └── digitalocean
            └── godo
                ├── .git                            # البيانات الوصفية لمستودع جيت
                ├── account.go                      # ملف الحزمة
                ├── account_test.go             # اختبار ملف الحزمة
                ├── ...
                ├── timestamp.go
                ├── timestamp_test.go
                └── util
                    ├── droplet.go
                    └── droplet_test.go

بدءًأ من الإصدار 1.8 يُعَدّ المجلد الافتراضي لمساحة العمل في جو هو المجلد الرئيسي home directory للمستخدِم الذي يحتوي على مجلد فرعي باسم go أي HOME/go$، فإذا كنت تستخدِم إصدارًا أقدم من 1.8، فمن الأفضل الاستمرار في استخدام الموقع HOME/go$ لمساحة عملك.

نفِّذ الأمر التالي لإنشاء بنية مجلد لمساحة العمل الخاصة بك في جو:

$ mkdir -p $HOME/go/{bin,src}

يطلب الخيار p- من mkdir إنشاء جميع العناصر الرئيسية parents في المجلد حتى لو لم تكن موجودة حاليًا، كما يؤدي استخدام {bin,src} إلى إنشاء مجموعة من الوسائط لـ mkdir وإخباره بإنشاء كل من مجلدَي bin و src.

سيؤدي ذلك إلى إنشاء بنية المجلد التالية:

└── $HOME
    └── go
        ├── bin
        └── src

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

يمكن ضبط المتغير GOPATH$ الخاص بك من خلال إضافة المتغيرات العامة إلى bash_profile./~.

أولًا، افتح bash_profile./~ باستخدام nano أو محرر النصوص المفضل لديك:

$ nano ~/.bash_profile

اضبط المتغير GOPATH$ الخاص بك من خلال إضافة ما يلي إلى الملف:

export GOPATH=$HOME/go

عندما يُصرّف ويثبّت جو الأدوات، فإنه سيضعها في المجلد GOPATH/bin$، ومن الشائع إضافة المجلد الفرعي bin/ الخاص بمساحة العمل إلى PATH في bash_profile./~:

export PATH=$PATH:$GOPATH/bin

أضف الآن ما يلي إلى ملف bash_profile./~:

export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

سيسمح لك ذلك بتشغيل أية برامج تصرفها أو تحملها عبر أدوات جو في أيّ مكان على نظامك.

نفّذ الأمر التالي لتحميل المتغيرات العامة وتحديث الصدَفة:

$ . ~/.bash_profile

يمكنك يمكنك التحقق من تحديث المتغير PATH$ باستخدام الأمر echo وقراءة الخرج:

$ echo $PATH

ستشاهد GOPATH/bin$ الذي سيظهر في مجلد home، فإذا سجلت الدخول على أساس مستخدِم عادي وليكن sammy، فسترى ‎/Users/sammy/go/bin في المسار:

/Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

الآن بعد أن أنشأت المجلد الجذر لمساحة العمل وضبطت مجموعة متغيرات البيئة GOPATH$ الخاصة بك، أصبح بإمكانك إنشاء مشاريعك باستخدام بنية المجلد التالية، كما يفترض هذا المثال أنك تستخدِم موقع Github لاستضافة مشروعك:

$GOPATH/src/github.com/username/project

إذا كنت تعمل على مشروع https://github.com/digitalocean/godo مثلًا، فستخزنه في المجلد التالي:

$GOPATH/src/github.com/digitalocean/godo

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

go get github.com/digitalocean/godo

يمكنك أيضًا التحقق من نجاح عملية التحميل من خلال عرض محتويات المجلد:

ls -l $GOPATH/src/github.com/digitalocean/godo

يجب أن تشاهد خرجًا يشبه الخرج التالي:

Output
-rw-r--r--  1 sammy  staff   2892 Apr  5 15:56 CHANGELOG.md
-rw-r--r--  1 sammy  staff   1851 Apr  5 15:56 CONTRIBUTING.md
.
.
.
-rw-r--r--  1 sammy  staff   4893 Apr  5 15:56 vpcs.go
-rw-r--r--  1 sammy  staff   4091 Apr  5 15:56 vpcs_test.go

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

الخطوة 6 - إنشاء برنامج بسيط

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

افتح محرر نصوص سطر الأوامر nano من المجلد الرئيسي وأنشئ ملفًا جديدًا:

$ nano hello.go

اكتب برنامجك في الملف الجديد:

package main

import "fmt"

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

ستستخدِم هذه الشيفرة حزمة fmt وستستدعي الدالة Println لطباعة عبارة Hello, World!‎ التي مُرِّرت إلى الدالة.

اخرج الآن من المحرر nano بالضغط على مفتاحي CTRL+ x وعند مطالبتك بحفظ الملف اضغط على y ثم ENTER، وبمجرد الخروج من nano والعودة إلى الصدَفة شغّل برنامج hello.go الذي أنشأته:

go run hello.go

سترى الخرج التالي:

Hello, World!

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

خاتمة

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

ترجمة -وبتصرُّف- للمقال How To Install Go and Set Up a Local Programming Environment on macOS لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: تثبيت لغة جو وإعداد بيئة برمجة محلية على أبونتو
• فهم، تنصيب وتهيئة بيئة عمل لغة البرمجة Go
• كتابة أول برنامج (ومكتبة) لك باستخدام لغة البرمجة Go

تُعَدّ جو Go لغة برمجة حديثة ذات قواعد syntax عالية المستوى على غرار لغات البرمجة النصية مثل بايثون وروبي وجافاسكربت، وقد طوّرتها شركة جوجل Google في عام 2007 لتكون ملائمةً لنوعية احتياجات جوجل الحسابية من حيث التصريف compilation السريع وسهولة البرمجة والتنفيذ الفعّال.

تُعَدّ جو لغةً بسيطةً جدًا من ناحية القواعد، فعدد الكلمات المفتاحية بها والأنواع الأساسية فيها ضئيل مقارنة بباقي اللغات، كما أنها تقلل كثيرًا من فكرة وجود طرق متعددة لتنفيذ مهمة ما، حتى أنها لا تحتوي على حلقة while وتقتصر فقط على حلقة for، مما يجعل هذه اللغة سهلة التعلم ومناسبةً للمبرمجين الجدد والخبراء ويميّزها عن باقي اللغات، كما تعالِج جو عمليات التزامن بصورة مبتكرة، بالإضافة إلى توفير الأدوات اللازمة لبناء ملفات ثنائية أصيلة native binaries مثل برامج تنفيذية executables أو مكتبات مشتركة shared libraries لاستخدامها في منصات وأماكن أخرى.

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

المتطلبات

حاسوب -أو آلة افتراضية- مثبت عليه نظام أبونتو 20.04 مع إمكانية وصول إدارية والاتصال بالانترنت.

الخطوة 1- إعداد جو

الخطوة الأولى هي تثبيت جو عن طريق تحميل الإصدار الحالي من جو من الصفحة الرسمية، لذا يجب أن تحصل على عنوان URL لآخر نسخة من ملف Tarball (أو tarfile؛ اسم المجموعة أو أرشيف الملفات المُصرّفة معًا باستخدام الأمر tar)، كما يجب عليك الانتباه إلى قيمة SHA256 المدرَجة بجوارها لأنك ستحتاجها للتحقق من الملف الذي حُمِّل. في وقت كتابة هذه المقالة كان أحدث إصدار go1.16.7.

سننجز عملية التثبيت من خلال سطر الأوامر command line -ومعروف أيضًا باسم الصدفة shell أو الطرفية Terminal وهو وسيلة تخاطب مع الحاسوب عبر كتابة الأوامر له- الذي يُمكّنك من تعديل وأتمتة العديد من المهام التي تؤديها على جهاز الحاسوب كل يوم، وهو أداة أساسية لمطورِي البرامج.

يمكنك العثور على تطبيق سطر الأوامر من خلال النقر على أيقونة أبونتو في الزاوية العلوية اليسرى من شاشتك وكتابة Terminal في شريط البحث ثم انقر على أيقونة تطبيق الطرفية لفتحه أو يمكنك الضغط على مفاتيح CTRL + ALT + T على لوحة المفاتيح في الوقت نفسه لفتح تطبيق الطرفية تلقائيًا.

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

تأكد من أنك في المجلد home (~) قبل بدء تحميل جو:

$ cd ~

استخدم الأمر curl للحصول على عنوان URL الخاص بالملف tarball الذي نسخته من الصفحة الرسمية لجو:

$ curl -OL https://golang.org/dl/go1.16.7.linux-amd64.tar.gz

استخدم التجزئة sha256sum للتحقق من صلاحية ملف tarball:

$ sha256sum go1.16.7.linux-amd64.tar.gz

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

go1.16.7.linux-amd64.tar.gz
7fe7a73f55ba3e2285da36f8b085e5c0159e9564ef5f63ee0ed6b818ade8ef04  go1.16.7.linux-amd64.tar.gz

استخرِج بعد ذلك الأرشيف الذي حمِّل وثبّته في الموقع المطلوب على النظام، ويوصى في المسار usr/local/. يتضمن هذا الأمر الراية C- التي ترشد tar إلى المجلد المحدد قبل تنفيذ أي عمليات أخرى.

$ sudo tar -C /usr/local -xvf go1.16.7.linux-amd64.tar.gz

أصبح لديك الآن مجلدًا باسم go في المسار usr/local/، وبذلك تكون قد حمّلت وثبّت جو على نظام أبونتو الخاص بك.

الخطوة 2 - إنشاء مساحة العمل Workspace الخاصة بك

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

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

من المحتمل أن يحتوي المجلد src على عدة مستودعات للتحكم في الإصدارات مثل Git و Mercurial و Bazaar، إذ سيسمح لك هذا باستيراد أساسي canonical import للشيفرة البرمجية في مشروعك، والاستيراد الأساسي هو عملية استيراد تشير إلى حزمة مؤهلة وجاهزة بالكامل مثل github.com/digitalocean/godo.

سترى مجلدات مثل github.com أو golang.org أو غيرها عندما يستورد برنامجك مكتبات تابعة لجهات خارجية، فإذا كنت تستخدِم -أو لديك- شيفرات برمجية على إحدى المواقع مثل github.com، فستضع أيضًا هذه المشاريع أو ملفات المصدر ضمن هذا المجلد وستتعرّف على ذلك بعد قليل.

تبدو مساحة العمل النموذجية كما يلي:

.
├── bin
│   ├── buffalo                                      # أمر تنفيذي
│   ├── dlv                                          # أمر تنفيذي
│   └── packr                                        # أمر تنفيذي
└── src
    └── github.com
        └── digitalocean
            └── godo
                ├── .git                            # البيانات الوصفية لمستودع جيت
                ├── account.go                      # ملف الحزمة
                ├── account_test.go             # اختبار ملف الحزمة
                ├── ...
                ├── timestamp.go
                ├── timestamp_test.go
                └── util
                    ├── droplet.go
                    └── droplet_test.go

يُعَدّ المجلد الافتراضي لمساحة العمل في جو بدءًأ من الإصدار 1.8 هو المجلد الرئيسي home للمستخدِم الذي يحتوي على مجلد فرعي باسم go أي HOME/go$، فإذا استخدَمت إصدارًا أقدم من 1.8، فمن الأفضل الاستمرار في استخدام الموقع HOME/go$ لمساحة عملك.

نفّذ الأمر التالي لإنشاء بنية مجلد لمساحة العمل الخاصة بك في جو:

$ mkdir -p $HOME/go/{bin,src}

يطلب الخيار p- من mkdir إنشاء جميع العناصر الرئيسية parents في المجلد حتى لو لم تكن موجودة حاليًا، إذ يؤدي استخدام {bin، src} إلى إنشاء مجموعة من الوسائط لـ mkdir وإخباره بإنشاء كل من مجلد bin و src.

سيؤدي ذلك إلى إنشاء بنية المجلد التالية:

└── $HOME
    └── go
        ├── bin
        └── src

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

يمكن ضبط المتغير GOPATH$ الخاص بك من خلال إضافة المتغيرات العامة إلى ‎~/.profile‎‎ وربما تحتاج أيضًا إلى إضافته إلى ملف zshrc. أو bashrc. تبعًا لتهيئة الصدَفة shell الخاصة بك.

أولًا، افتح ‎~/.profile‎‎ باستخدام nano أو محرر النصوص المفضل لديك:

$ nano ~/.profile

حدِّد المتغير GOPATH$ الخاص بك من خلال إضافة ما يلي إلى الملف:

export GOPATH=$HOME/go

عندما يُصرّف جو الأدوات ويثبّتها، فسيضعها في المجلد GOPATH/bin$، ومن الشائع إضافة المجلد الفرعي bin/ الخاص بمساحة العمل إلى PATH في ‎~/.profileكما يلي:

export PATH=$PATH:$GOPATH/bin

سيسمح لك ذلك بتشغيل أيّ برامج مُصرَّفة بواسطة جو أو محمّلة عبر أدوات جو من أيّ مكان على نظامك.

أخيرًا، ستحتاج إلى إضافة المجلد bin إلى المسار PATH من خلال إضافة المسار usr/local/go/bin/ في نهاية السطر كما يلي:

export PATH=$PATH:$GOPATH/bin:/usr/local/go/bin

أصبح بإمكانك الآن الوصول إلى جميع أدوات جو من أيّ مكان على نظامك.

نفّذ الأمر التالي لتحميل المتغيرات العامة وتحديث الصدَفة:

. ~/.profile

يمكنك التحقق من تحديث المتغير PATH$ باستخدام الأمر echo وقراءة الخرج:

$ echo $PATH

ستشاهد GOPATH/bin$ الخاص بك والذي سيظهر في مجلد home، فإذا سجّلت الدخول على أساس جذر، فسترى root/go/bin/ في المسار.

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

ستشاهد أيضًا المسار الخاص بأدوات جو ضمن المجلد usr/local/go/bin/:

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

تحقق الآن من التثبيت عن طريق التحقق من الإصدار الحالي من جو:

$ go version

سيظهر لك خرج يشبه التالي:

go version go1.12.1 linux/amd64

الآن بعد أن أنشأتَ المجلد الجذر لمساحة العمل وضبطت مجموعة متغيرات البيئة GOPATH$ الخاصة بك، أصبح بإمكانك إنشاء مشاريعك باستخدام بنية المجلد التالية، وسيفترض هذا المثال أنك تستخدِم موقع github.com لاستضافة مشروعك:

$GOPATH/src/github.com/username/project

إذا كنت تعمل على مشروع https://github.com/digitalocean/godo على سبيل المثال، فسيُخزَّن في المجلد التالي:

$GOPATH/src/github.com/digitalocean/godo

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

$ go get github.com/digitalocean/godo

سيؤدي ذلك إلى تحميل محتويات مكتبة godo وإنشاء المجلد GOPATH/src/github.com/digitalocean/godo$ على جهازك.

يمكنك أيضًا التحقق من نجاح عملية تحميل حزمة godo من خلال سرد محتويات المجلد:

$ ll $GOPATH/src/github.com/digitalocean/godo

يجب أن تشاهد خرجًا يشبه الخرج التالي:

drwxr-xr-x 4 root root  4096 Apr  5 00:43 ./
drwxr-xr-x 3 root root  4096 Apr  5 00:43 ../
drwxr-xr-x 8 root root  4096 Apr  5 00:43 .git/
-rwxr-xr-x 1 root root     8 Apr  5 00:43 .gitignore*
-rw-r--r-- 1 root root    61 Apr  5 00:43 .travis.yml
-rw-r--r-- 1 root root  2808 Apr  5 00:43 CHANGELOG.md
-rw-r--r-- 1 root root  1851 Apr  5 00:43 CONTRIBUTING.md
.
.
.
-rw-r--r-- 1 root root  4893 Apr  5 00:43 vpcs.go
-rw-r--r-- 1 root root  4091 Apr  5 00:43 vpcs_test.go

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

الخطوة 3 - إنشاء برنامج بسيط في جو

ستنشئ برنامج “Hello, World!” بغية اختبار مساحة العمل والتعرف أكثر على جو. ستنشئ هنا ملف مصدري واحد لجو وليس مشروعًا فعليًا، لذا لا داعي لأن تكون ضمن مساحة العمل الخاصة بك لإنجاز ذلك.

افتح محرر نصوص سطر الأوامر nano من المجلد الرئيسي وأنشئ ملفًا جديدًا:

$ nano hello.go

اكتب برنامجك في الملف الجديد:

package main

import "fmt"

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

ستستخدِم هذه الشيفرة حزمة fmt وستستدعي الدالة Println لطباعة Hello, World!‎ التي تم مرِّرت على أساس وسيط إلى الدالة.

اخرج الآن من المحرر nano بالضغط على مفتاحَي CTRL+ X، وعند مطالبتك بحفظ الملف، اضغط على Y ثم ENTER.

شغِّل برنامج hello.go الذي أنشأته عند الخروج من nano والعودة إلى الصدَفة:

go run hello.go

سترى الخرج التالي:

Hello, World!

بذلك يكون اختبار مساحة عملك قد أكتمل.

خاتمة

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

ترجمة -وبتصرُّف- للمقال How To Install Go on Ubuntu 20.04 لصاحبه Gopher Guides.

اقرأ أيضًا

• فهم، تنصيب وتهيئة بيئة عمل لغة البرمجة Go
• كتابة أول برنامج (ومكتبة) لك باستخدام لغة البرمجة Go

تعلم كيفية حلّ المشاكل الشائعة في أنظمة المعالجة المتزامنة وتفادى صداع المرافق لحلّها في المستقبل.

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

الفحص المتزامن لمقاييس الارتباط

تعتمد خوارزمية HALO (وهي اختصارًا Hop-by-Hop Adaptive Link-State Optimal Routing) على التوجيه الديناميكي جزئيًا على مقاييس الارتباط لحساب جدول التوجيه الخاص بها. تُجمعُ هذه المقاييس من خلال مكون مستقل متواجد بكلّ PoP (نقطة مشاركة). أما نقاط المشاركة (PoPs) وهي آلات تمثل كيانًا موجهًا واحدًا في شبكاتنا، ومتصلة بارتباطات متعددة وتنتشر في مواقع كثيرة مشكلةً بذلك شبكتنا. يستكشف هذا المكون الأجهزة المجاورة باستخدام حزم الشبكة، وسيُردُ هؤلاء الجيران بجواب أولي. يمكن استخلاص قيم زمن تأخير الارتباط من الأجوبة المتلقاة من هذه النقاط. نظرًا لأن لكل نقطة اتصال أكثر من جار واحد، فإن طبيعة هذه المهمة متزامنة جوهريًا: نحتاج إلى قياس وقت الاستجابة لكل رابط مجاور في الوقت الفعلي. لا يمكننا تحمل المعالجة التسلسلية ويجب معالجة كلّ جواب بأقرب وقت ممكن لحساب مقياس الارتباط.

أرقام التسلسل وإعادة الضبط: حالة إعادة الترتيب

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

عملية تأسيس اتصال UDP وحالات الآلة المحدودة

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

لتطبيق هذا الأمر تطبيقًا صحيحًا، يجب علينا تحديد حالات الآلة المحدودة وكما يجب أن تكون الانتقالات واضحة بينهم. وهذا بدوره سيسمح لنا بإدارة جميع حالات الحرجة لتأسيس الاتصال تأسيسًا صحيحًا.

تُنشأ مُعرّفات الجلسة من خلال مؤسس الاتصالات. ويكون التسلسل الكامل لعملية الإنشاء على الشكل التالي:

1. يرسل المرسل حزمة SYN(ID)‎.
2. يخزن المُستقبل المُعرّف الواصل له (وهو ID) ويرسل SYN-ACK (ID)‎.
3. يتلقى المرسل SYN-ACK (ID)‎ ويرسل ACK (ID)‎. كما يبدأ أيضًا في إرسال الحزم الّتي تبدأ بالتسلسل رقم 0.
4. يتحقق المرسل من آخر معرّف ID استلمه، ويقبل ACK (ID)‎ إذا كان معرّفه مطابقًا للمعرّف (ID) السابق. كما يبدأ بقبول الحزم الّتي تبدأ برقم تسلسلي 0.

معالجة المُهلة الزمنية للحالة

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

• أحداث الارتباط: وهي تحديث لحالة الارتباط فإما عملية ارتباط أو عملية فصل الارتباط. يمكن لهذا إما بدء جلسة اتصال أو إنهاء جلسة موجودة.
• أحداث تراسل الحزم: وهي لحزم التحكم مثل: (SYN/SYN-ACK/ACK) أو استقصاء الاستجابات فقط.
• أحداث انتهاء المُهلة: هي الأحداث الّتي تُشغّل بعد انتهاء المهلة المُجدولة لحالة الجلسة الحالية.

يكمن التحدي الرئيسي الّذي نواجهه هنا هو كيفية التعامل مع انتهاء زمن المُهلة المتزامنة والأحداث الأخرى بنفس الوقت. وهنا يمكن للمرء أن يسقط بسهولة في مشاكلة القفل المستعصي (Deadlocks) ومشكلة السباق (Race conditions).

النهج الأول

سنستخدم في هذا المشروع لغة Golang لإنها توفر آليات مزامنة أصيلة مثل: القنوات والأقفال الأصيلة وهي قادرة أيضًا على تدوير الخيوط (Threads) الخفيفة لمعالجتهم بطريقة متزامنة (لمزيد من المعلومات يمكنك الاطلاع على مقال سابق أخذنا فيه نظرة سريعة على لغة Golang).

سنبدأ أولًا بتصميم هيكلًا (Struct) لتمثيل مُعالجات جلسات العمل والمُهلة.

type  Session  struct  {    
  State SessionState    
  Id SessionId    
  RemoteIp  string    
}  

type  TimeoutHandler  struct  {    
  callback  func(Session)    
  session Session    
  duration  int    
  timer  *timer.Timer    
}

تُحددُ (Session) جلسة الاتصال بمعرّف الجلسة (ID)، وعنوان IP للارتباط المجاور (RemoteIp)، وحالة الجلسة الحالية (State).

كما يحدد معالج المُهلة (TimeoutHandler) بدالّة رد النداء (callback)، والجلسة الّتي يجب أن يعمل من أجلها (session)، والمدة (duration)، ومؤشر للوقت المُجدول (timer).

ستُخزن خارطة (أو خريطة) عامة (Global Map) -الخرائط Maps في لغة Go هي مصفوفات ترابطية يمكن التعديل عليها ديناميكيًا وهي تشبه نوع القاموس او الهاش في اللغات البرمجية الأخرى- مُعالج المُهلة المُجدولة لكل جلسة ارتباط مجاورة.

SessionTimeout map[Session]*TimeoutHandler

تُسجّل مُهلةٌ ما وتُلغى بالدوالّ التالية:

// الدالّة المسؤولة عن جدولة المهلة لرد النداء
func (timeout* TimeoutHandler) Register() {  
  timeout.timer = time.AfterFunc(time.Duration(timeout.duration) * time.Second, func() {  
    timeout.callback(timeout.session)  
  })  
}

func (timeout* TimeoutHandler) Cancel() {  
  if timeout.timer == nil {  
    return  
  }  
  timeout.timer.Stop()  
}

لإنشاء المُهل وتخزينها، يمكنك استخدام دالّة مشابه لهذه:

func CreateTimeoutHandler(callback func(Session), session Session, duration int) *TimeoutHandler {  
  if sessionTimeout[session] == nil {  
    sessionTimeout[session] := new(TimeoutHandler)  
  }  

  timeout = sessionTimeout[session]  
  timeout.session = session  
  timeout.callback = callback  
  timeout.duration = duration  
  return timeout  
}

بمجرد إنشاء معالج المُهلة وتسجيله بنجاح، سيُشغل عندها رد النداء بعد انقضاء المدة الزمنية (duration) المقدرة بالثانية. بينما بعض الأحداث الأخرى ستتطلبُ منك إعادة جدولة معالج المُهلة (كما يحدث في حالة SYN - كلّ 3 ثوان).

لذلك، يمكنك إعادة جدولة المُهلة لرد نداء معين. هكذا:

func synCallback(session Session) {  
  sendSynPacket(session)

  // reschedules the same callback.  
  newTimeout := NewTimeoutHandler(synCallback, session, SYN_TIMEOUT_DURATION)  
  newTimeout.Register()

  sessionTimeout[state] = newTimeout  
}

سيعيد رد النداء جدولة نفسه في معالج مهلة جديد ويحدّث الخارطة العامة بقيمة sessionTimeout الجديدة.

سباق البيانات والمراجع

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

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

1. لديك معالج (handler) مجدول بمُهلة معينة.
2. الخيط 1 (Thread 1):
   أ) تتلقى حزمة تحكم، وتريد الآن إلغاء المُهلة المسجلة والانتقال لحالة الجلسة التالية. (مثلًا، أن تتلقى SYN-ACK بعد إرسال ** SYN **).
   ب) يمكنك استدعاء الدالّة timeout.Cancel()‎، والّتي بدورها ستستدعي الدالّة timer.Stop()‎. (لاحظ أن توقف مؤقت لغة Golang لن يمنع تشغيل المؤقت الّذي انتهت مدته الزمنية بالفعل).
3. الخيط 2:
   أ) قبل استدعاء دالة الإلغاء مباشرةً، انقضت المدة الزمنية للمؤقت، وكان رد النداء على وشك التنفيذ.
   ب) نفذَّ رد النداء، وسجُلّت المُهلة الجديدة وحُدّثت أيضًا الخارطة العامة.
4. الخيط 1:
   أ) الانتقال لحالة الجلسة الجديدة وتسجيل مُهلة جديدة، وتحديث الخارطة العامة.

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

هل يعد استخدام القفل كافيًا لحل المشكلة؟

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

func (timeout* TimeoutHandler) Register() {  
  timeout.timer = time.AfterFunc(time.Duration(timeout.duration) * time._Second_, func() {  
    stateLock.Lock()  
    defer stateLock.Unlock()

    timeout.callback(timeout.session)  
  })  
}

إن الفرق الآن هو أن التحديثات على الخارطة العامة متزامنة، ولكن هذا لا يمنع رد النداء من العمل بعد استدعاء الدالّة timeout.Cancel()‎ - وتحدث هذه الحالة إذا انتهت المدة الزمنية للمؤقت المُجدول ولكنه لم يجلب القفل بعد. عندها يجب أن تُفقدُ مرة أخرى الإشارة لأحد المُهل المسجلة.

استخدام قنوات الإلغاء

بدلًا من الاعتماد على الدالّة timer.Stop()‎ في لغة Golang، الّذي لن يمنع رد النداء المنتهية مُهلته الزمنية من التنفيذ، سنعتمد على قنوات الإلغاء.

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

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

func (timeout *TimeoutHandler) Register() chan struct{} {  
  cancelChan := make(chan struct{})  

  go func () {  
    select {  
    case _ = <- cancelChan:  
      return  
    case _ = <- time.AfterFunc(time.Duration(timeout.duration) * time.Second):  
      func () {  
        stateLock.Lock()  
        defer stateLock.Unlock()

        timeout.callback(timeout.session)  
      } ()  
    }  
  } ()

  return cancelChan  
}

func (timeout* TimeoutHandler) Cancel() {  
  if timeout.cancelChan == nil {  
    return  
  }  
  timeout.cancelChan <- struct{}{}  
}

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

الحل في هذه الحالة هو التحقق من قناة الإلغاء بداخل نطاق المُهلة بعد جلب القفل.

  case _ = <- time.AfterFunc(time.Duration(timeout.duration) * time.Second):  
    func () {  
      stateLock.Lock()  
      defer stateLock.Unlock()  

      select {  
      case _ = <- handler.cancelChan:  
        return  
      default:  
        timeout.callback(timeout.session)  
      }  
    } ()  
  }

أخيرًا، هذا سيضمنُ أن يُنفذّ رد النداء فقط بعد جلب القفل وقبل تفعيل الإلغاء.

احذر من مشكلة القفل المستعصي

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

حاول أن تعيد قراءة الشيفرة البرمجية أعلاه وأن تحاول العثور عليها بنفسك. فكر في الاستدعاءات المتزامنة للدوالّ الموضحة.

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

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

func (timeout* TimeoutHandler) Cancel() {  
  if timeout.cancelChan == nil {  
    return  
  }  

  select {  
  case timeout.cancelChan <- struct{}{}:  
  default:  
    // can’t send on the channel, someone has already requested the cancellation.  
  }  
}

الخلاصة

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

تحديث البيانات المشتركة بدون مزامنة

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

فقدان عمليات التحقق من الحالة

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

في مثالنا، تلقى مُعالج المُهلة استدعاء الاستيقاظ (لفك حالة السُبات) من مؤقت منتهية مُهلته الزمنية، ولكنه لا يزال بحاجة للتحقق من أن إشارة الإلغاء قد أرسلت إليه بالفعل قبل أن يتابع تنفيذ رد النداء.

مشكلة القفل المستعصي

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

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

ترجمة -وبتصرف- للمقال Lessons learned from programming in Go لكاتبه Eduardo Ferreira

سنتعرف في هذا المقال على إيجابيات وسلبيات تخزين البيانات في Go باستخدام المصفوفات Arrays والشرائح Slices ولماذا يكون أحدها أفضل من الآخر عادةً.

هذا المقال جزء من سلسلة Go التي كتبها Mihalis Tsoukalos:

• الجزء 1: إنشاء كلمات مرور عشوائية وآمنة في Go
• الجزء 2: بناء خادم TCP متزامن في لغة البرمجة Go.
• الجزء 3: 3 طرائق لنسخ الملفات في لغة البرمجة Go.

المصفوفات Arrays

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

يمكنك تعريف مصفوفة Array في لغة البرمجة Go، تحت اسم anArray مثلًا والتي تُخزِّن أربعة أعداد صحيحة كما يلي:

anArray := [4]int{-1, 2, 0, -4}

يُحدَّد حجم المصفوفة Array Size أولًا، ثم نوعها Array Type، وأخيرًا عناصرها Array Elements.

تُساعدك الدّالة ()len في معرفة طول المصفوفة فحجم المصفوفة السابقة هو 4.

إذا كنت على درايةٍ بلغات برمجة أخرى، فقد حاولت الوصول لجميع عناصر المصفوفة باستخدام حلقة for. ومع ذلك، كما سترى لاحقًا، أنّ الكلمة المفتاحية range الخاصة بلغة Go تُتيح لك الوصول لجميع عناصر المصفوفة أو الشريحة بسلاسة.

وأخيرًا، إليك كيفية تحديد مصفوفة ذات بُعدين two dimentional array:

twoD := [3][3]int{
    {1, 2, 3},
    {6, 7, 8},
    {10, 11, 12}}

الملف المصدر arrays.go يُوضِّح كيفية استخدام مصفوفات Go، ها هو الكود الأكثر أهمية في ملف arrays.go:

for i := 0; i < len(twoD); i++ {
        k := twoD[i]
        for j := 0; j < len(k); j++ {
                fmt.Print(k[j], " ")
        }
        fmt.Println()
}

for _, a := range twoD {
        for _, j := range a {
                fmt.Print(j, " ")
        }
        fmt.Println()
}

يوضح هذا كيف يُمكنك المرور على عناصر المصفوفة باستخدام for loop والكلمة المُفتاحية range. توضّح باقي الكود الخاص بالملف arrays.go كيفية تمرير المصفوفة كمعامل دالّة.

فيما يلي هو ناتج arrays.go:

$ go run arrays.go
Before change(): [-1 2 0 -4]
After change(): [-1 2 0 -4]
1 2 3
6 7 8
10 11 12
1 2 3
6 7 8
10 11 12

يوضح هذا الناتج أنّ التغييرات التي تُجريها على مصفوفة داخل دالة تُفقَد بعد إنتهاء الدالة.

عيوب ومساوئ المصفوفات arrays

لدى مصفوفات Go العديد من المساوئ التي لابد أن تأخذها بعين الإعتبار حينما تستخدمها في مشاريع Go.

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

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

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

الحل لجميع هذه المشاكل هو استخدام الشرائح Slices التي توفرها Go.

الشرائح Slices

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

الشرائح لها خاصية سعة وخاصية طول، وهما ليستا نفس الشيء دائمًا. طول الشريحة هو نفس طول المصفوفة التي تحتوي على نفس عدد العناصر، ويمكن معرفتها باستخدام الدالة ()len. أمّا سعة الشريحة فهي الغرفة التي تم تخصيصها حاليًا للشريحة، ويمكن معرفتها باستخدام الدالة ()cap.

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

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

يتم توضيح شرائح Go في ملف slice.go، والذي يحتوي على الكود التالي:

package main

import (
        "fmt"
)

func negative(x []int) {
        for i, k := range x {
                x[i] = -k
        }
}

func printSlice(x []int) {
        for _, number := range x {
                fmt.Printf("%d ", number)
        }
        fmt.Println()
}

func main() {
        s := []int{0, 14, 5, 0, 7, 19}
        printSlice(s)
        negative(s)
        printSlice(s)

        fmt.Printf("Before. Cap: %d, length: %d\n", cap(s), len(s))
        s = append(s, -100)
        fmt.Printf("After. Cap: %d, length: %d\n", cap(s), len(s))
        printSlice(s)

        anotherSlice := make([]int, 4)
        fmt.Printf("A new slice with 4 elements: ")
        printSlice(anotherSlice)
}

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

بالإضافة إلى ذلك، تتيح لك الدالة ()append إضافة عنصر إلى شريحة موجودة؛ لاحظ أنه حتى إذا كانت سعة الشريحة تسمح لك بإضافة عنصر إلى هذه الشريحة فلن يتم تعديل طولها ما لم تستخدم ()append.

الدالة ()printSlice هي دالة مُساعدة، تُستخدم لطباعة عناصر معامل الشريحة الخاص بها، في حين أنّ الدالة ()negative تقوم بعمل معالجة لعناصر مُعامل الشريحة الخاص بها.

ها هو ناتج slice.go:

$ go run slice.go
0 14 5 0 7 19
0 -14 -5 0 -7 -19
Before. Cap: 6, length: 6
After. Cap: 12, length: 7
0 -14 -5 0 -7 -19 -100
A new slice with 4 elements: 0 0 0 0

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

الشرائح كمرجع للمصفوفات

تُتيح لك Go الاشارة إلى مصفوفة موجودة بشريحة باستخدام الترميز [:]. في هذه الحالة، ستنعكس أي تغييرات تجريها على دالة شريحة إلى المصفوفة - وهذا موضّح في refArray.go. يرجى تذكُّر أن الترميز [:] لا يُنشئ نسخة من المصفوفة، بل فقط يُشير إليها.

الجزء الأكثر إثارة للاهتمام في refArray.go هو:

func main() {
        anArray := [5]int{-1, 2, -3, 4, -5}
        refAnArray := anArray[:]

        fmt.Println("Array:", anArray)
        printSlice(refAnArray)
        negative(refAnArray)
        fmt.Println("Array:", anArray)
}

ناتج refArray.go هو:

$ go run refArray.go
Array: [-1 2 -3 4 -5]
-1 2 -3 4 -5
Array: [1 -2 3 -4 5]

لذلك، تغيرت عناصر مجموعة anArray بسبب الإشارة إلى الشريحة.

الملخص

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

يمكنك العثور على كود Go الخاص بـ arrays.go و slice.go و refArray.go على GitHub.

ترجمة -وبتصرف- للمقال An introduction to Go arrays and slices لصاحبه Mihalis Tsoukalos

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

هذا المقال جزء من سلسلة Go التي كتبها Mihalis Tsoukalos. اقرأ الجزء 1: إنشاء كلمات مرور عشوائية وآمنة في Go، والجزء 2: إنشاء خادم TCP متزامن في Go.

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

1. استخدام استدعاء دالة ()io.copy من مكتبة Go.
2. قراءة ملف الإدخال مرة واحدة وكتابته إلى ملف آخر.
3. نسخ الملف في قطع صغيرة باستخدام مخزن مؤقت.

الطريقة الأولى: استخدام ()io.copy

الإصدار الأول من هذه الطريقة يستخدم الدالة ()io.copy من مكتبة Go. يمكنك العثور على منطق هذه الطريقة من خلال الإطّلاع على كود الدالة ()copy، وهي كما يلي:

func copy(src, dst string) (int64, error) {
        sourceFileStat, err := os.Stat(src)
        if err != nil {
                return 0, err
        }

        if !sourceFileStat.Mode().IsRegular() {
                return 0, fmt.Errorf("%s is not a regular file", src)
        }

        source, err := os.Open(src)
        if err != nil {
                return 0, err
        }
        defer source.Close()

        destination, err := os.Create(dst)
        if err != nil {
                return 0, err
        }
        defer destination.Close()
        nBytes, err := io.Copy(destination, source)
        return nBytes, err
}

بصرف النظر عن اختبار ما إذا كان الملف الذي سيتم نسخه موجودًا (عبر (os.Stat (src)، وهو ملف عادي (يمكن التأكد عبر sourceFileStat.Mode().IsRegular()‎)، حتى تتمكن من فتحه للقراءة، يتم تنفيذ كل العمل بواسطة الجملة التعريفية (io.copy(destination, Source السابقة.

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

يُمكنك معرفة المزيد عن ()io.copy بالإطّلاع على صفحة التوثيق الخاصة بـالـ io Package.

سيؤدي تنفيذ cp1.go إلى إنشاء النوع التالي من النواتج:

$ go run cp1.go
Please provide two command line arguments!
$ go run cp1.go fileCP.txt /tmp/fileCPCOPY
Copied 3826 bytes!
$ diff fileCP.txt /tmp/fileCPCOPY

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

الطريقة الثانية: استخدام ()ioutil.WriteFile و ()ioutil.ReadFile

الطريقة الثانية لنسخ ملف هي استخدام الدوال ()ioutil.ReadFile و ()ioutil.WriteFile. تقرأ الدالة الأولى محتويات ملف بأكمله في شريحة بايت، بينما تقوم الدالة الثانية بكتابة محتويات شريحة بايت في ملف.

يمكنك العثور على منطق هذه الطريقة في كود Go التالي:

  input, err := ioutil.ReadFile(sourceFile)
        if err != nil {
                fmt.Println(err)
                return
        }

        err = ioutil.WriteFile(destinationFile, input, 0644)
        if err != nil {
                fmt.Println("Error creating", destinationFile)
                fmt.Println(err)
                return
        }

بصرف النظر عن كتلتي if، التي تُعد جزءًا من طريقة عمل Go، تستطيع أن ترى أنّ الأداء الوظيفي للبرنامج موجود في كلٍ من ()ioutil.ReadFile و ()ioutil.WriteFile.

سيؤدي تنفيذ cp2.go إلى إنشاء نوع الناتج التالي:

$ go run cp2.go
Please provide two command line arguments!
$ go run cp2.go fileCP.txt /tmp/copyFileCP
$ diff fileCP.txt /tmp/copyFileCP

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

الطريقة الثالثة: استخدام ()os.read و ()os.write

الطريقة الثالثة لنسخ ملفات في Go، هي استخدام وسيلة cp3.go المُطوّرة في هذا القسم.

تأخذ ثلاث معاملات:

1. اسم ملف الإدخال.
2. اسم ملف الإخراج.
3. حجم المخزن المؤقت.

يتواجد الجزء الأكثر أهمية من cp3.go في الحلقة for التالية، والذي يمكن العثور عليه في الدالة ()copy:

     buf := make([]byte, BUFFERSIZE)
        for {
                n, err := source.Read(buf)
                if err != nil && err != io.EOF {
                        return err
                }
                if n == 0 {
                        break
                }

                if _, err := destination.Write(buf[:n]); err != nil {
                        return err
                }
        }

تستخدم هذه التقنية الدالة ()os.read لقراءة أجزاء صغيرة من ملف الإدخال في المخزن المؤقت المُسمى buf. وتستخدم الدالة ()os.write لكتابة محتويات هذا المخزن المؤقت إلى ملف.

تتوقف عملية النسخ عندما يكون هناك خطأ في القراءة أو عند الوصول إلى نهاية الملف (io.EOF).

سيؤدي تنفيذ cp3.go إلى إنشاء نوع الناتج التالي:

$ go run cp3.go
usage: cp3 source destination BUFFERSIZE
$ go run cp3.go fileCP.txt /tmp/buf10 10
Copying fileCP.txt to /tmp/buf10
$ go run cp3.go fileCP.txt /tmp/buf20 20
Copying fileCP.txt to /tmp/buf20

كما سترى، يؤثر حجم المخزن المؤقت بشكل كبير على أداء cp3.go.

بعض من التقييم بهدف الموازنة

سيحاول الجزء الأخير من هذ المقال موازنة البرامج الثلاثة بالإضافة إلى أداء cp3.go لمختلف أحجام المخزن المؤقت باستخدام الأداة المساعدة لسطر الأوامر (time (1.

يُظهر الناتج التالي أداء cp1.go و cp2.go و cp3.go عند نسخ ملف بحجم 500 ميجابايت:

$ ls -l INPUT
-rw-r--r--  1 mtsouk  staff  512000000 Jun  5 09:39 INPUT
$ time go run cp1.go INPUT /tmp/cp1
Copied 512000000 bytes!

real    0m0.980s
user    0m0.219s
sys     0m0.719s
$ time go run cp2.go INPUT /tmp/cp2

real    0m1.139s
user    0m0.196s
sys     0m0.654s
$ time go run cp3.go INPUT /tmp/cp3 1000000
Copying INPUT to /tmp/cp3

real    0m1.025s
user    0m0.195s
sys     0m0.486s

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

الآن، دعنا نختبر كيف يؤثر حجم المخزن المؤقت على أداء cp3.go. سيؤدي تنفيذ cp3.go بحجم المخزن المؤقت 10 و 20 و 1000 بايت لنسخ ملف 500 ميجابايت على جهاز سريع إلى حد كبير لاستخراج النتائج التالية:

$ ls -l INPUT
-rw-r--r--  1 mtsouk  staff  512000000 Jun  5 09:39 INPUT
$ time go run cp3.go INPUT /tmp/buf10 10
Copying INPUT to /tmp/buf10

real    6m39.721s
user    1m18.457s
sys         5m19.186s
$ time go run cp3.go INPUT /tmp/buf20 20
Copying INPUT to /tmp/buf20

real    3m20.819s
user    0m39.444s
sys         2m40.380s
$ time go run cp3.go INPUT /tmp/buf1000 1000
Copying INPUT to /tmp/buf1000

real    0m4.916s
user    0m1.001s
sys     0m3.986s

يُظهر الناتج الذي تم إنشاؤه أنه كلما زاد حجم المخزن المؤقت، كلما كان أداء cp3.go أسرع، وهو أمر مُتوَقع إلى حدٍ ما. علاوةً على ذلك، يُعد استخدام أحجام المخازن المؤقتة أصغر من 20 بايت لنسخ الملفات الكبيرة عملية بطيئة للغاية ويجب تجنُّبها.

يمكنك العثور على كود Go الخاص بـ cp1.go و cp2.go و cp3.go على Github.

ترجمة وبتصرّف للمقال 3 ways to copy files in Go، لصاحبه Mihalis Tsoukalos.

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

تعمل خوادم TCP و UDP بخدمة عملاء الشبكة في كل مكان عبر شبكات TCP / IP. لكل اتصال وارد من عميل TCP، سيقوم خادم TCP ببدء تشغيل goroutine جديد لمعالجة هذا الطلب.

تستطيع إيجاد هذا المشروع concTCP.go على GitHub.

التعامل مع اتصالات TCP

يمكنك العثور على منطق البرنامج في دالة ()handleConnection بلغة Go، والذي يتم تنفيذه على النحو التالي:

func handleConnection(c net.Conn) {
        fmt.Printf("Serving %s\n", c.RemoteAddr().String())
        for {
                netData, err := bufio.NewReader(c).ReadString('\n')
                if err != nil {
                        fmt.Println(err)
                        return
                }

                temp := strings.TrimSpace(string(netData))
                if temp == "STOP" {
                        break
                }

                result := strconv.Itoa(random()) + "\n"
                c.Write([]byte(string(result)))
        }
        c.Close()
}

إذا أرسل عميل TCP سلسلة التعليمات "STOP"، فسيتم إنهاء برنامج Go أي goroutine الذي يخدم عميل TCP محدد؛ وإلا، سيرسل خادم TCP رقمًا عشوائيًا إلى عميل TCP.

تضمن الحلقة for أن عميل TCP سيتم خدمته طالما يُتَطلب ذلك. تقرأ الحلقة for الموجودة في كود Go البيانات من عميل TCP سطرًا بسطر باستخدام ('bufio.NewReader(c).ReadString('\n وتُعيد إرسال البيانات باستخدام (((c.Write([]byte(string(result.

التزامن

تنفيذ دالة ()main، يُعطي أمرًا لخادم TCP لبدء تشغيل برنامج goroutine جديد في كل مرة يتعين عليه خدمة عميل TCP:

func main() {
        arguments := os.Args
        if len(arguments) == 1 {
                fmt.Println("Please provide a port number!")
                return
        }

        PORT := ":" + arguments[1]
        l, err := net.Listen("tcp4", PORT)
        if err != nil {
                fmt.Println(err)
                return
        }
        defer l.Close()
        rand.Seed(time.Now().Unix())

        for {
                c, err := l.Accept()
                if err != nil {
                        fmt.Println(err)
                        return
                            }
                go handleConnection(c)
        }
}

أولاً، تتأكد ()main من أن البرنامج يحتوي على وسيطة سطر أوامر واحدة على الأقل.

لاحظ أن الكود الموجود لا يتحقق مما إذا كانت وسيطة سطر الأوامر المحددة هي رقم مَنفذ TCP صالح أم لا. ومع ذلك، إذا لم تكن القيمة المحددة رقم منفذ TCP صالحًا، فسوف يفشل استدعاء ()net.Listen مع ظهور رسالة خطأ مشابهة لما يلي:

$ go run concTCP.go 12a
listen tcp4: lookup tcp4/12a: nodename nor servname provided, or not known
$ go run concTCP.go -10
listen tcp4: address -10: invalid port

يتم استخدام استدعاء ()net.Listen لإخبار برنامج Go بقبول اتصالات الشبكة وبالتالي كخادم. قيمة الإرجاع ()net.Listen هي من النوع net.Conn، والتي تنفذ واجهات io.Reader و io.Writer.

تقوم الدالة ()main أيضًا باستدعاء الدالة ()rand.seed لتهيئة مُنشئ الأرقام العشوائية.

أخيرًا، تُتيح حلقة for للبرنامج الحفاظ على قبول عملاء TCP الجدد باستخدام ()accept والتي سيتم معالجتها بواسطة نسخ الدالة ()handleConnection، والتي يتم تنفيذها على شكل goroutines.

أول معامل للدالة ()net.Listen

يُحدد المعامل الأول من الدالة ()net.Listen نوع الشبكة التي سيتم استخدامها، بينما يُحدد المعامل الثاني عنوان الخادم بالإضافة إلى رقم المَنفذ الذي سيستمع إليه الخادم.

القيم الصالحة للمُعامل الأول هي:

tcp, tcp4 (IPv4-only), tcp6 (IPv6-only), udp, udp4 (IPv4- only), udp6 (IPv6-only), ip, ip4 (IPv4-only), ip6 (IPv6-only), Unix (Unix sockets), Unixgram, Unixpacket

فعالية خادم TCP المتزامن

يتطلب concTCP.go وسيطة سطر أوامر واحدة، وهي رقم المَنفذ الذي سيستمع إليه. سيكون الناتج الذي ستحصل عليه من concTCP.go عند خدمة عملاء TCP مشابهًا لما يلي:

$ go run concTCP.go 8001
Serving 127.0.0.1:62554
Serving 127.0.0.1:62556

يمكن لناتج (1)netStat التحقق من أن concTCP.go يخدم العديد من عملاء TCP أثناء الاستماع لمزيد من الاتصالات:

$ netstat -anp TCP | grep 8001
tcp4       0      0  127.0.0.1.8001         127.0.0.1.62556    ESTABLISHED
tcp4       0      0  127.0.0.1.62556        127.0.0.1.8001     ESTABLISHED
tcp4       0      0  127.0.0.1.8001         127.0.0.1.62554    ESTABLISHED
tcp4       0      0  127.0.0.1.62554        127.0.0.1.8001     ESTABLISHED
tcp4       0      0  *.8001                 *.*                    LISTEN

يعلمنا السطر الأخير من ناتج الأمر السابق أن هناك عملية تستمع إلى المَنفذ 8001، مما يعني أنه لا يزال بإمكانك الاتصال بمنفذ TCP رقم 8001. يتحقق أول سطرين من وجود اتصال شبكة TCP ثابت يستخدم أرقام المنافذ 8001 و 62556. وبالمثل، يتحقق السطران الثالث والرابع من وجود اتصال TCP آخر يستخدم أرقام المنافذ 8001 و 62554.

تُظهر هذه الصورة ناتج concTCP.go عند خدمة العديد من عملاء TCP:

بشكل مشابه، تُظهر الصورة التالية الناتج من عميلين من TCP يتم تنفيذهما باستخدام (1)nc:

يُمكنك ايجاد معلومات أكثر عن (1)nc، والتي تُدعى أيضًا (1)netcat على ويكيبيديا.

الملخص

لقد تعلمت للتو كيفية تطوير خادم TCP متزامن يقوم بإنشاء أرقام عشوائية باستخدام حوالي 65 سطرًا من كود Go، وهو أمر مثير للإعجاب جدًا!

إذا كنت تريد أن يقوم خادم TCP بمهمة مختلفة، فقط قم بتغيير تنفيذ الدالة ()handleConnection.

ترجمة وبتصرّف للمقال Build a concurrent TCP server in Go، لصاحبه Mihalis Tsoukalos.

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

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

قبل التعمُّق في الأدوات المساعدة والكود الخاص بـ Go، ألقِ نظرة على هذه المجموعة الفرعية من جدول ASCII كما هو موجود في ناتج الأمر man ascii:

 30 40 50 60 70 80 90 100 110 120
 ---------------------------------
0:    (  2  <  F  P  Z  d   n   x
1:    )  3  =  G  Q  [  e   o   y
2:    *  4  >  H  R  \  f   p   z
3: !  +  5  ?  I  S  ]  g   q   {
4: "  ,  6  @  J  T  ^  h   r   |
5: #  -  7  A  K  U  _  i   s   }
6: $  .  8  B  L  V  `  j   t   ~
7: %  /  9  C  M  W  a  k   u  DEL
8: &  0  :  D  N  X  b  l   v
9: '  1  ;  E  O  Y  c  m   w

القيم العشرية لرموز ASCII تتراوح من 33 إلى 126؛ لا توجد قيم ASCII أخرى مناسبة لتتواجد ضمن كلمات المرور. لذلك، سوف تنتج الأدوات المساعدة المقدَّمة في هذا المقال أحرف ASCII في هذا النطاق.

خلق أعداد صحيحة عشوائية

الأداة المساعدة الأولى تُدعى random.go، وتقوم بإنشاء عدد محدد من الأعداد الصحيحة العشوائية ضمن نطاق معين.

الجزء الأكثر أهمية في random.go هو هذه الدالة:

func random(min, max int) int {
        return rand.Intn(max-min) + min
}

تقوم هذه الدالّة بإنشاء أعداد صحيحة عشوائية تنتمي إلى نطاق معين باستخدام ()rand.intn. لاحظ أنّ rand.intn()‎ تقوم بإرجاع رقم عشوائي غير سالب ينتمي إلى المجال [0,n)، إذ n هو العدد المُمرَّر إلى الدالة. ستخرب الدالة إذا كان مُعاملها عددًا سالبًا وستكون رسالة الخطأ كما يلي:

panic: invalid argument to Intn

يُمكنك إيجاد توثيق المجموعة math/rand في هذا الرابط: math/rand Documentation.

تقبل الدالة random.go ثلاثًا من عوامل سطر الأوامر (Command Line Parameters):

1. الحد الأدنى لقيمة الأعداد الصحيحة المراد توليدها.

2. والقيمة القصوى.

3. وعدد الأعداد الصحيحة التي سيتم توليدها.

تجميع وتنفيذ random.go سيخلق هذا النوع من الناتج:

$ go build random.go
$ ./random
Usage: ./random MIX MAX TOTAL
$ ./random 1 3 10
2 2 1 2 2 1 1 2 2 1

إذا كنت ترغب في إنشاء أرقام عشوائية أكثر أمانًا في Go، فاستخدم حزمة crypto / rand من مكتبة Go.

إنشاء كلمات مرور عشوائية

الأداة المساعدة الثانية randomPass.go، تنشئ كلمات مرور عشوائية. يستخدم randomPass.go الدالة ()random لإنشاء أرقام عشوائية سيتم تحويلها إلى رموز ASCII باستخدام كود Go التالي:

for {
        myRand := random(MIN, MAX)
        newChar := string(startChar[0] + byte(myRand))
        fmt.Print(newChar)
        if i == LENGTH {
                break
        }
        i++
}

قيمة MIN هي 0 وقيمة MAX هي 94، في حين أن قيمة startChar هي !، وهو أول حرف قابل للطباعة في جدول ASCII (برمز ASCII العشري وهو 33). لذلك، توجد جميع أحرف ASCII التي سيتم إنشاؤها بعد ! وقبل الحرف ~، الذي يحتوي على رمز ASCII العشري لـلرقم 126.

لذلك، كل رقم عشوائي يتم إنشاؤه أكبر من MIN، وأصغر من MAX، ويتم تحويله إلى رمز ASCII. تستمر العملية حتى تصبح كلمة المرور التي تم إنشاؤها لها بالطول المطلوب.

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

$ go run randomPass.go 1
Z
$ go run randomPass.go 10
#Cw^a#IwkT
$ go run randomPass.go
Using default values!
[PP8@'Ci

تفصيل أخير: لا تنس استعمال ()rand.seed مع قيمة أولية لتهيئة مولد الأرقام العشوائية. إذا استخدمت نفس القيمة الأولية في كل وقت، فسيقوم مُولِّد الأرقام العشوائية بإنشاء نفس تسلسل الأعداد الصحيحة العشوائية.

تستطيع إيجاد كلًا من random.go و randomPass.go على GitHub. وتستطيع أيضًا تنفيذ هذه الدوال على play.golang.org

ترجمة -وبتصرف- للمقال Creating random, secure passwords in Go لصاحبه Mihalis Tsoukalos.

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

Nginx هو أحد أشهر خوادم الويب في العالم نظرًا لاستخدامه الخفيف للموارد وموثوقيته في حال وجود حمل زائد. تعتمد العديد من المواقع الضخمة والأكثر زيارةً على Nginx لتقدّم محتواها. في النشر، غالبًا ما يُستخدم Nginx موازن حمل(load balancer) أو وكيل عكسي (reverse proxy) لزيادة الأمان وجعل التطبيق أكثر قوة. بالتزامن مع لغة Go لتطوير الواجهة الخلفية في الويب، يمكن لخادم Nginx تقديم تطبيق ويب سريع وقوي.

ستتعلم في هذا الدرس كيفية بناء تطبيق ويب Hello World بلغة Go وننشره على خادم أوبنتو 18.04 مستخدمين Nginx كخادم عكسي.

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

لمتابعة هذا الدرس، ستحتاج إلى ما يلي:

• خادم أوبنتو 18.04 تم ضبطه باتباع التهيئة الأولية لخادم أوبنتو 18.04، متضمنًا مستخدمًا عاديًا بصلاحيات sudo وجدار حماية.
• يجب أن تكون لغة Go مثبّتة على حاسوبك.
• خادم Nginx مثبّت باتّباع الدرس كيف تثبّت خادم Nginx على أوبنتو 18.04. لا تتبع الخطوة 5 - إعداد كتل الخادم؛ ستنشئ كتلة خادم Nginx لاحقًا في هذا الدرس.
• اسم نطاق يشير إلى خادمك. سنستخدم your_domain في هذا الدرس. هذا ضروري للحصول على شهادة SSL لموقعك، حتى يمكنك أن تقدّم تطبيقك بأمان مع تشفير TLS.

بالإضافة إلى ذلك، لتحقيق نشر بدرجة الإنتاج لتطبيق الويب Go، من المهم أن تحافظ على خادمك آمنًا بتثبيت شهادة TLS/SSL. أرشح لك هذه الخطوة بشدة. لتؤمّن تطبيق الويب Go، اتّبع كيف تؤمّن خادم Nginx بشهادة Let's Encrypt على أوبنتو بعد الخطوة 3 من هذا الدرس لتحصل على شهادة TLS/SSL مجانية.

الخطوة 1: بناء تطبيق ويب بلغة البرمجة Go

في هذه الخطوة، ستبني نموذج تطبيق ويب بلغة Go يعرض عبارة Hello World على نطاقك your_domain ويقوم بتحيّة المستخدم على الرابط your_domain/greet/. إذا كنت تريد تعلّم المزيد من أساسيات البرمجة في Go، تفحّص مقالتنا كيف تكتب برنامجك الأول بلغة Go.

بدايةً، أنشئ مجلد جديد في مجلد GOPATH ليتضمن الملف المصدري. يمكنك تسمية المجلد بأي اسم تريده، ولكن في هذا الدرس سنستخدم اسم go-web:

$ mkdir $GOPATH/go-web

باتّباع بنية الملف المقترحة في درس فهم، تنصيب وتهيئة بيئة عمل لغة البرمجة Go، سيعطي هذا مجلدك المسار ‎~/go/go-web:

بعد ذلك، نفّذ التعليمة التالية لتغيّر المجلد إلى مجلدك الذي أنشأته حديثًا في GOPATH:

$ cd $GOPATH/go-web

استخدم محرر النصوص nano أو المحرر المفضل لك لإنشاء ملف باسم main.go، والذي سيتضمن الشيفرة المصدرية لتطبيقك الويب:

$ nano main.go

لإنشاء وظيفة التطبيق Hello World، أضف شيفرة Go التالية إلى ملف main.go المنشأ حديثًا:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello World")
    })

    http.HandleFunc("/greet/", func(w http.ResponseWriter, r *http.Request) {
        name := r.URL.Path[len("/greet/"):]
        fmt.Fprintf(w, "Hello %s\n", name)
    })

    http.ListenAndServe(":9990", nil)
}

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

كتبت أولًا نقطة الدخول إلى تطبيقك:

package main
…

تخبر تعليمة package main مُصرِّف Go أن يصرّف هذا الملف على أنّه برنامجٌ تنفيذي بدلًا من أن يكون مكتبة مشتركة (shared library).

ثمّ لديك تعليمات import:

…

import (
    "fmt"
    "net/http"
)
…

يستورد هذا الجزء الوحدات الضرورية لعمل هذه الشيفرة، والتي تشمل حزمة fmt القياسية وحزمة net/http لخادم الويب الخاص بك.

يُنشئ الجزء التالي مسارك الأول في الدالة main والتي هي نقطة الدخول لأي تطبيق Go:

…
func main () {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello World")
    })
  …
}
…

أنشئ المسار الأب / ضمن الدالة func main، التي ستعيد النص Hello World عندما تُطلب.

كما هو موضح في الجزء التالي فإنّ المسار الثاني يقبل معاملًا في الرابط (URL parameter)، في هذه الحالة اسمًا، لعرضه مصحوبًا بالتحية.

…
func main () {
  …
    http.HandleFunc("/greet/", func(w http.ResponseWriter, r *http.Request) {
        name := r.URL.Path[len("/greet/"):]
        fmt.Fprintf(w, "Hello %s\n", name)
    })
…
}
…

يستخدم هذا URL.Path الخاص بلغة Go لتخزين القيمة مباشرةً بعد /greet/ وتمريرها كاسم من معامل الرابط.

أخيرًا، هيّئ الخادم:

…
func main () {
  …
  http.ListenAndServe(":9990", nil)
}

يشغّل الجزء السابق الخادم ويعرض تطبيقك عبر المنفذ 9990 باستخدام خادم http المدمج بلغة Go.

احفظ الملف وأغلق المحرر النصي بمجرد الانتهاء من فحص الشيفرة في main.go.

بعد ذلك، ابنِ الملف الثنائي القابل للتنفيذ لتطبيقك باستخدام الأمر:

$ go build main.go

التعليمة السابقة ستصرِّف الملف main.go لإنتاج ملف قابل للتنفيذ باسم main.

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

الخطوة 2: إنشاء ملف وحدة Systemd

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

بدايةً، أنشئ ملفًا جديدًا في مجلد ‎/lib/systemd/system باسم goweb.service باستخدام محرر النصوص nano أو محرر النصوص المفضّل لك:

$ sudo nano /lib/systemd/system/goweb.service

لضبط معاملات الخدمة، أضف الجزء التالي في الملف.

[Unit]
Description=goweb

[Service]
Type=simple
Restart=always
RestartSec=5s
ExecStart=/home/user/go/go-web/main

[Install]
WantedBy=multi-user.target

يحدّد المتغير ExecStart=/home/user/go/go-web/main أنَّ نقطة الدخول لهذه الخدمة عبر الملف main القابل للتنفيذ الموجود في المجلد ‎/home/user/go/go-web، إذ user هو اسم المستخدم لحساب المستخدم العادي الذي يملك صلاحيات sudo على الخادم. Restart=always تضمن أنَّ systemd سيحاول دائمًا أن يعيد تشغيل البرنامج إذا توقف. في السطر التالي، RestartSec=5s يضبط وقت انتظار لخمس ثوانٍ بين محاولات إعادة التشغيل. يحدِّد WantedBy=multi-user.target في أي حالة سيفعّل الخادم الخدمة.

احفظ وأغلق الملف.

بعد أن كتبت ملف وحدة الخدمة، شغّل خدمة الويب Go باستخدام الأمر:

$ sudo service goweb start

للتأكّد فيما إذا كانت الخدمة شغّالة، استخدم الأمر التالي:

$ sudo service goweb status

ستستقبل الخرج التالي:

Output
● goweb.service - goweb
   Loaded: loaded (/lib/systemd/system/goweb.service; disabled; vendor preset: enabled)
   Active: active (running) since Wed 2019-07-17 23:28:57 UTC; 6s ago
 Main PID: 1891 (main)
    Tasks: 4 (limit: 1152)
   CGroup: /system.slice/goweb.service
           └─1891 /home/user/go/go-web/main

لتتعلم المزيد عن العمل مع ملف وحدة systemd، ألقِ نظرة على فهم وحدات وملفات وحدة Systemd.

الآن بعد أن أصبح لديك تطبيقًا شغّالًا، يمكنك ضبط الوكيل العكسي Nginx.

الخطوة 3: ضبط وكيل عكسي مع Nginx

ستنشئ في هذه الخطوة كتلة خادم Nginx وستضبط الوكيل العكسي Nginx لتعرض تطبيقك على الإنترنت.

أولًا، غيّر مجلد العمل الخاص بك إلى مجلد sites-available على الخادم Nginx:

$ cd /etc/nginx/sites-available

أنشئ ملفًا جديدًا باسم النطاق الذي تريد عرض تطبيقك عليه. سيستخدم هذا الدرس الملف your_domain:

$ sudo nano your_domain

أضف الأسطر التالية إلى الملف لوضع الإعدادات لـ your_domain:

server {
    server_name your_domain www.your_domain;

    location / {
        proxy_pass http://localhost:9990;
    }
}

كتلة الخادم Nginx تستخدم proxy_pass لتقديم تطبيق الويب Go على عنوان IP لخادمك المشار إليه على أنّه مضيف محلي localhost لتشغيله على المنفذ 9990 . يشير server_name إلى اسم النطاق المعيّن لعنوان IP الخاص بك، في هذه الحالة your_domain وwww.your_domain.

بعد ذلك، أنشئ رابطًا رمزيًا لإعدادات Nginx هذه في مجلد sites-enabled بتشغيل الأمر التالي:

$ sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/your_domain

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

بعدها، أعد تحميل إعدادات Nginx بتشغيل تعليمة إعادة التحميل:

$ sudo nginx -s reload

لتتأكد أن نشرك يعمل، قم بزيارة http://your_domain في متصفحك، إذ ستتم تحيتك بسلسلة نصية Hello World.

ملاحظة: كما ذُكر في قسم المتطلبات الأساسية، يُنصح في هذه النقطة أن يتم تفعيل SSL/TLS على خادمك. سيضمن ذلك تشفير جميع الاتصالات بين التطبيق وزوّاره، وهو أمر مهم بشكلٍ خاص إذا طلب التطبيق معلومات حساسة مثل تسجيل الدخول أو كلمة المرور. اتّبع الآن درس كيف تؤمّن خادم Nginx بشهادة Let's Encrypt على أوبنتو لتحصل على شهادة SSL مجانية لخادم Nginx على أوبنتو 18.04. بعد أن تحصل على شهادات SSL/TLS خاصة بك، عُد وأكمل هذا الدرس.

ضبطت الآن الوكيل العكسي Nginx لتعرض تطبيقك على اسم النطاق الخاص بك، وقمت بتأمين تطبيق الويب Go مع SSL/TLS. في الخطوة التالية، ستختبر تطبيقك عبر اتصالٍ آمن.

الخطوة 4: اختبار التطبيق

في هذه الخطوة، ستختبر تطبيقك عبر اتصالٍ آمن لتتأكد من أنَّ كل شيء يعمل.

افتح متصفح الويب المفضل لك، وقم بزيارة https://your_domain:

ستستقبل رسالة Hello World بسيطة. استقبال هذه الرسالة عند استخدام https://‎ في الرابط يشير إلى أنَّ التطبيق يُعرض عبر اتصالٍ آمن.

بعد ذلك، حاول زيارة المسار الثاني https://your_domain/greet/your-name مستبدلًا بالعبارة your-name أيّ اسم آخر تريد أن يلقي عليه تطبيقك التحيّة:

سيعيد التطبيق تحيّة بسيطة مع your-name، الذي يعتمد على المعامل الممرّر للرابط.

حالما تستقبل هذه النتائج، تكون قد نشرت تطبيق ويب Go بنجاح.

خاتمة

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

ترجمة -وبتصرف- للمقال How To Deploy a Go Web Application Using Nginx on Ubuntu 18.04 لصاحبه Michael Okoh

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

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

إعداد بيئة العمل

الخطوة الأولى هي - بالطبع - تثبيتُ Go. يمكن تثبيت Go من المستودعات الرسمية على توزيعات لينكس؛ مثلا بالنسبة لأوبونتو:

sudo apt install golang-go

إصدارات Go الموجودة في المستودعات الرسمية تكون في العادة أقدم قليلا من تلك الموجودة على الموقع الرسمي، إلا أنها تؤدي الغرض؛ علاوة على سهولة التثبيت. يمكنك تثبيت إصدارات أحدث على أوبونتو (هنا) وCentos (هنا).

بالنسبة لمستخدمي نظام Mac OS فيمكنهم تثبيت اللغة عن طريق Homebrew:

brew install go

يحوي الموقع الرسمي كذلك الملفات التنفيذية لتثبيت اللغة على أغلب أنظمة التشغيل، بما في ذلك ويندوز.

تأكّد من تثبيت Go بتنفيذ الأمر التالي:

go version

مثال لنتيجة اﻷمر أعلاه (على توزيعة أوبونتو):

go version go1.6.2 linux/amd64

– روابط للتثبيت على وندوز وإعداد المسارات –

توجد الكثير من محرّرات النصوص والإضافات المتاحة لكتابة شفرات Go. أفضّل شخصيّا محرّر الشفرات Sublime Text وإضافة GoSublime؛ إلا أن طريقة كتابة Go تتيح استخدام محرّرات نصوص عاديّة بسهولة خصوصا للمشاريع الصغيرة. أعمل مع محترفين يقضون كامل اليوم في البرمجة بلغة Go باستخدام محرّر النصوص Vim، دون أي إضافة لإبراز صيغة الشفرات البرمجية Syntax highlighting. بالتأكيد لن تحتاج لأكثر من محرّر نصوص بسيط للبدء في تعلّم Go.

مشروع جديد

إن لم تكن أنشأت مجلّدا للعمل أثناء تثبيت Go وإعداده فالوقت مناسب لذلك.
تتوقّع أدوات Go أن توجد جميع الشفرات البرمجية على المسار GOPATH/src$، وبالتالي سيكون عملنا دائما في هذا المجلّد. يمكن لمجموعة أدوات Go كذلك أن تتخاطب مع مشاريع مُضيَّفة على مواقع مثل GitHub وBitbucket إن أُعدّت لذلك.

سننشئ لأغراض هذا الدرس مستودعا جديدا فارغا على GitHub ولنسمّه “hello” (أو أي اسم يناسبك). ننشئ مجلّدا ضمن مجلّد GOPATH لاستقبال ملفات المستودع (أبدل your-username باسم المستخدم الخاصّ بك على GitHub):

mkdir -p $GOPATH/src/github.com/your-username
cd $GOPATH/src/github.com/your-username

ننسخ المستودع ضمن المجلّد الذي أنشأناه أعلاه:

git clone git@github.com:your-username/hello
cd hello

سننشئ الآن ملفا باسم main.go ليحوي برنامجا قصيرا بلغة Go:

package main

func main() {
    println("hello!")
}

نفّذ الأمر go build لتصريف جميع محتويات المجلّد الحالي. سينتُج ملف تنفيذي بنفس الاسم؛ يمكنك بعدها طلب تشغيله بذكر اسمه على النحو التالي:

go build
./hello

النتيجة:

hello!

ما زلت رغم سنوات من التطوير بلغة Go أبدأ مشاريعي بنفس الطريقة: مستودع Git فارغ، ملف main.go وبضعة أوامر.

يصبح أي تطبيق يتبع الطرق المتعارف عليها لتنظيم شفرة Go قابلا للتثبيت بسهولة بالأمر go get. إن أودعت على سبيل المثال الملف أعلاه ودفعته إلى مستودع Git فإن أي شخص لديه بيئة عمل Go يمكنه تنفيذ الخطوتين التاليتين لتشغيل البرنامج:

go get github.com/your-username/hello
$GOPATH/bin/hello

إنشاء خادوم وب

فلنجعل برنامجنا البسيط السابق خادوم وب:

package main

import "net/http"

func main() {
    http.HandleFunc("/", hello)
    http.ListenAndServe(":8080", nil)
}

func hello(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello!"))
}

هناك بضعة سطور تحتاج للشرح.

نحتاج أولا لاستيراد الحزمة net/httpمن المكتبة المعيارية لـGo:

import "net/http"

ثم نثبّت دالة معالجة Handler function في المسار الجذر لخادوم الوِب. تتعامل http.HandleFunc مع الموجّه المبدئي لطلبات Http في Go، وهو ServeMux.

http.HandleFunc("/", hello)

الدالة hello هي من النوع http.HandlerFunc الذي يسمح باستخدام دوال عاديّة على أنها دوال معالجة لطلبات HTTP. للدوال من النوع http.HandlerFunc توقيع Signature خاص (توقيع الدالة هو المعطيات المُمرَّرة لها وأنواع البيانات التي تُرجعها هذه الدالة) ويمكن تمريرها في معطى إلى الدالة HandleFunc التي تسجّل الدالة المُمرَّرة في المُعطى لدى الموجِّه ServeMux، وبالتالي يُنشئ خادوم الوِب، في كلّ مرة يصله فيها طلب جديد يطابق المسار الجذر، يُنشئ نسخة جديدة من الدالة hello.

تستقبل الدالة hello متغيّرا من النوع http.ResponseWriter الذي تستخدمه الدالة المُعالِجة لإنشاء إجابة HTTP وبالتالي إنشاء ردّ على طلب العميل عن طريق التابع Write الذي يوفّره النوع http.ResponseWriter. بما أن التابع http.ResponseWriter.Write يأخذ معطى عامًّا من النوع []byte أو byte-slice، فنحوّل السلسة النصيّة hello إلى النوع المناسب:

func hello(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello!"))
}

في الأخير نشغّل خادوم وب على المنفذ 8080 عبر الدالة http.ListenAndServe التي تستقبل معطيَين، الأول هو المنفَذ Port والثاني دالة معالجة. إذا كانت قيمة المعطى الثاني هي nil فهذا يعني أننا نريد استخدام الموجّه المبدئي DefaultServeMux. هذا الاستدعاء متزامن Synchronous، أو معترِض Blocking، يبقي البرنامج قيد التشغيل إلى أن يُقطَع الاستدعاء.

صرّف وشغّل البرنامج بنفس الطريقة السابقة:

go build
./hello

افتح سطر أوامر - طرفيّة - آخر وأرسل طلب HTTP إلى المنفذ 8080:

curl http://localhost:8080

النتيجة:

hello!

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

إضافة مسارات جديدة

يمكننا فعل أمور أكثر أهمية من مجرّد قول مرحبا (hello). فليكن المُدخَل اسم مدينة نستخدمه لاستدعاء واجهة تطبيقات برمجيّة API لأحوال الطقس ونعيد توجيه الإجابة - درجة الحرارة - في الرد على الطلب. توفّر خدمة OpenWeatherMap واجهة تطبيقات برمجيّة مجانيّة وسهلة الاستخدام للحصول على توقّعات مناخية. سجّل في الموقع للحصول على مفتاح API. يمكن الاستعلام من OpenWeatherMap حسب المدن. تُرجع واجهة التطبيقات البرمجية إجابة على النحو التالي (عدّلنا قليلا على النتيجة):

{
    "name": "Tokyo",
    "coord": {
        "lon": 139.69,
        "lat": 35.69
    },
    "weather": [
        {
            "id": 803,
            "main": "Clouds",
            "description": "broken clouds",
            "icon": "04n"
        }
    ],
    "main": {
        "temp": 296.69,
        "pressure": 1014,
        "humidity": 83,
        "temp_min": 295.37,
        "temp_max": 298.15
    }
}

المتغيّرات في Go ذات أنواع ثابتة Statical type، بمعنى أنه ينبغي التصريح بنوع البيانات التي تخزّنها المتغيّرات قبل استخدامها. لذا سيتوجّب علينا إنشاء بنية بيانات لمطابقة صيغة رد الواجهة البرمجية. لا نحتاج لحفظ جميبع المعلومات، بل يكفي أن نحتفظ بالبيانات التي نهتم بشأنها. سنكتفي الآن باسم المدينة ودرجة الحرارة المتوقّعة التي تأتي بوحدة الكيلفن Kelvin. سنعرّف بنية لتمثيل البيانات التي نحتاجها من خدمة التوقعات المناخية.

type weatherData struct {
    Name string `json:"name"`
    Main struct {
        Kelvin float64 `json:"temp"`
    } `json:"main"`
}

تعرّف الكلمة المفتاحية type بنية بيانات جديدة نسمّيها weatherData ونصرّح بكونها من النوع struct. يحوي كلّ حقل في المتغيّرات من نوع struct اسما (مثلا Name أو Main)، نوع بيانات (string أو struct آخر مجهول الاسم) وما يُعرَف بالوسم Tag. تشبه الوسوم في Go البيانات الوصفية Metadata، وتمكّننا من استخدام الحزمة encoding/json لإعادة صفّ الإجابة التي تقدّمها خدمة OpenWeatherMap وحفظها في بنية البيانات التي أعددناها. يتطلّب الأمر كتابة شفرة برمجية أكثر ممّا عليه الحال في لغات برمجيّة ذات أنواع ديناميكية للبيانات (بمعنى أنه يمكن استخدام متغيّر فور احتياجنا له دون الحاجة للتصريح بنوع البيانات) مثل روبي وبايثون، إلا أنه يمنحنا خاصيّة الأمان في نوع البيانات.

عرّفنا بنية البيانات، نحتاج الآن لطريقة تمكّننا من ملْء هذه البنية بالبيانات القادمة من واجهة التطبيقات البرمجية؛ سنكتُب دالة لهذا الغرض.

func query(city string) (weatherData, error) {
    resp, err := http.Get("http://api.openweathermap.org/data/2.5/weather?APPID=YOUR_API_KEY&q=" + city)
    if err != nil {
        return weatherData{}, err
    }

    defer resp.Body.Close()

    var d weatherData

    if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {
        return weatherData{}, err
    }

    return d, nil
}

تأخذ الدالة سلسلة محارف تمثّل المدينة وتُرجِع متغيّرا من بنية بيانات weatherData وخطأ. هذه هي الطريقة الأساسية للتعامل مع الأخطاء في Go. تغلّف الدوال سلوكا معيَّنا، ويمكن أن يخفق هذا السلوك. بالنسبة لمثالنا، يمكن أن يخفق طلب GET الذي نرسله لـOpenWeatherMap لأسباب عدّة، وقد تكون البيانات المُرجَعة غير تلك التي ننتظرها. نُرجِع في كلتا الحالتين خطأ غير فارغ Non-nil للعميل الذي يُنتظَر منه أن يتعامل مع هذا الخطأ بما يتناسب مع السياق الذي أرسل فيه الطلب.

إن نجح الطلب http.Get نؤجّل طلبا لغلق متن الإجابة لننفّذه بعد الخروج من نطاق Scope الدالة (أي بعد الرجوع من دالة طلب HTTP)، وهي طريقة أنيقة لإدارة الموارد. في أثناء ذلك نحجز بنية weatherData ونستخدم json.Decoder لقراءة بيانات الإجابة وإدخالها مباشرة في بنيتنا.

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

http.HandleFunc("/weather/", func(w http.ResponseWriter, r *http.Request) {
    city := strings.SplitN(r.URL.Path, "/", 3)[2]

    data, err := query(city)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "application/json; charset=utf-8")
    json.NewEncoder(w).Encode(data)
})

نعرّف دالة معالجة على السطر In-line بدلا من تعريفها منفصلة. نستخدم الدالة strings.SplitN لأخذ كل ما يوجد بعد /weather/ في المسار والتعامل معه على أنه اسم مدينة. ننفّذ الطلب وإن صادفتنا أخطاء نعلم العميل بها باستخدام الدالة المساعدة http.Error، ونوقف تنفيذ الدالة للدلالة على اكتمال طلب HTTP. إن لم يوجد خطأ نخبر العميل بأننا بصدد إرسال بيانات JSON إليه ونستخدم الدالة json.NewEncode لترميز محتوى weatherData بصيغة JSON مباشرة.

الشفرة لحدّ الساعة أنيقة، تعتمد أسلوبا إجرائيا Procedural ويسهل فهمها. لا مجال للخطأ في تفسيرها ولا يمكنها تجاوز الأخطاء الشائعة. إن نقلنا الدالة المعالجة لـ "hello, world" إلى المسار hello/ واستوردنا الحزم المطلوبة فسنحصُل على البرنامج المُكتمل التالي:

package main

import (
    "encoding/json"
    "net/http"
    "strings"
)

func main() {
    http.HandleFunc("/hello", hello)

    http.HandleFunc("/weather/", func(w http.ResponseWriter, r *http.Request) {
        city := strings.SplitN(r.URL.Path, "/", 3)[2]

        data, err := query(city)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        w.Header().Set("Content-Type", "application/json; charset=utf-8")
        json.NewEncoder(w).Encode(data)
    })

    http.ListenAndServe(":8080", nil)
}

func hello(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello!"))
}

func query(city string) (weatherData, error) {
    resp, err := http.Get("http://api.openweathermap.org/data/2.5/weather?APPID=YOUR_API_KEY&q=" + city)
    if err != nil {
        return weatherData{}, err
    }

    defer resp.Body.Close()

    var d weatherData

    if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {
        return weatherData{}, err
    }

    return d, nil
}

type weatherData struct {
    Name string `json:"name"`
    Main struct {
        Kelvin float64 `json:"temp"`
    } `json:"main"`
}

نصرّف البرنامج وننفّذه بنفس الطريقة التي شرحناها أعلاه:

go build
./hello

نفتح طرفيّة أخرى ونطلب المسار http://localhost:8080/weather/tokyo (الحرارة بمقياس كلفن):

curl http://localhost:8080/weather/tokyo

النتيجة:

{"name":"Tokyo","main":{"temp":295.9}}

الاستعلام من واجهات برمجية عدّة

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

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

type weatherProvider interface {
    temperature(city string) (float64, error) // in Kelvin, naturally
}

يمكننا الآن تحويل دالة الاستعلام من openWeatherMap السابقة إلى نوع بيانات يوافق الواجهة weatherProvider. بما أننا لا نحتاج لحفظ أي حالة لإجراء طلب HTTP GET فسنستخدم بنية struct فارغة، وسنضيف سطرا قصيرا في دالة الاستعلام الجديدة لتسجيل ما يحدُث عند الاتصال بالخدمات لمراجعته في ما بعد:

type openWeatherMap struct{}

func (w openWeatherMap) temperature(city string) (float64, error) {
    resp, err := http.Get("http://api.openweathermap.org/data/2.5/weather?APPID=YOUR_API_KEY&q=" + city)
    if err != nil {
        return 0, err
    }

    defer resp.Body.Close()

    var d struct {
        Main struct {
            Kelvin float64 `json:"temp"`
        } `json:"main"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {
        return 0, err
    }

    log.Printf("openWeatherMap: %s: %.2f", city, d.Main.Kelvin)
    return d.Main.Kelvin, nil
}

لا نريد سوى استخراج درجة الحرارة (بالكلفن) من الإجابة، لذا يمكننا تعريف بنية struct على السطر Inline. في ما عدا ذلك فإن الشفرة البرمجية مشابهة لدالة الاستعلام السابقة، ولكنّها معرَّفة على صيغة تابع Method لبنية openWeatherMap. تتيح لنا هذه الطريقة استخدام عيّنة Instance من openWeatherMap مكان الواجهة weatherProvider.

سنفعل نفس الشيء بالنسبة لخدمة Weather Underground. الفرق الوحيد مع الخدمة السابقة هو أننا سنخزّن مفتاح الواجهة البرمجية في بنية struct ثم نستخدمه في التابع.

يجدر ملاحظة أن Weather Underground لا تعالج أسماء المدن المتطابقة بنفس جودة تعامل Open WeatherMap، وهو ما ينبغي الانتباه إليه في التطبيقات الفعلية. لن نعالج هذا الأمر في مثالنا البسيط هذا.

type weatherUnderground struct {
    apiKey string
}

func (w weatherUnderground) temperature(city string) (float64, error) {
    resp, err := http.Get("http://api.wunderground.com/api/" + w.apiKey + "/conditions/q/" + city + ".json")
    if err != nil {
        return 0, err
    }

    defer resp.Body.Close()

    var d struct {
        Observation struct {
            Celsius float64 `json:"temp_c"`
        } `json:"current_observation"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {
        return 0, err
    }

    kelvin := d.Observation.Celsius + 273.15
    log.Printf("weatherUnderground: %s: %.2f", city, kelvin)
    return kelvin, nil
}

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

func temperature(city string, providers ...weatherProvider) (float64, error) {
    sum := 0.0

    for _, provider := range providers {
        k, err := provider.temperature(city)
        if err != nil {
            return 0, err
        }

        sum += k
    }

    return sum / float64(len(providers)), nil
}

لاحظ أن تعريف الدالة قريب جدّا من تعريف التابع temperature المُعرَّف في الواجهة weatherProvider. إن جمعنا الواجهات weatherProvider في نوع بيانات ثم عرّفنا تابعا باسم temperature على هذا النوع فسيمكننا إنشاء نوع جديد يجمع الواجهات weatherProvider.

type multiWeatherProvider []weatherProvider

func (w multiWeatherProvider) temperature(city string) (float64, error) {
    sum := 0.0

    for _, provider := range w {
        k, err := provider.temperature(city)
        if err != nil {
            return 0, err
        }

        sum += k
    }

    return sum / float64(len(w)), nil
}

رائع! سنتمكّن من تمرير multiWeatherProvider إلى أي دالة تقبل weatherProvider.

نربُط الآن خادوم HTTP بدالة temperature للحصول على درجات الحرارة عند طلب مسار به اسم مدينة:

func main() {
    mw := multiWeatherProvider{
        openWeatherMap{},
        weatherUnderground{apiKey: "your-key-here"},
    }

    http.HandleFunc("/weather/", func(w http.ResponseWriter, r *http.Request) {
        begin := time.Now()
        city := strings.SplitN(r.URL.Path, "/", 3)[2]

        temp, err := mw.temperature(city)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        w.Header().Set("Content-Type", "application/json; charset=utf-8")
        json.NewEncoder(w).Encode(map[string]interface{}{
            "city": city,
            "temp": temp,
            "took": time.Since(begin).String(),
        })
    })

    http.ListenAndServe(":8080", nil)
}

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

./hello
2015/01/01 13:14:15 openWeatherMap: tokyo: 295.46
2015/01/01 13:14:16 weatherUnderground: tokyo: 273.15

$ curl http://localhost:8080/weather/tokyo
{"city":"tokyo","temp":284.30499999999995,"took":"821.665230ms"}

جعل الاستعلامات تعمل بالتوازي

نكتفي لحدّ الساعة بالاستعلام من الواجهات البرمجية بالتتالي، الواحدة تلو الأخرى. لا يوجد ما يمنعنا من الاستعلام من الواجهتيْن البرمجيّتين في نفس الوقت، وهو ما سياسهم في تقليل الوقت اللازم للإجابة.

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

func (w multiWeatherProvider) temperature(city string) (float64, error) {
    // ننشئ قناتيْن، واحدة لدرجات الحرارة والأخرى للأخطاء
    // يُضيف كل مزوّد خدمة قيمة إلى إحدى القناتيْن فقط
    temps := make(chan float64, len(w))
    errs := make(chan error, len(w))

    // نطلق بالنسبة لكلّ مزوّد خدمة وحدة فرعية جديدة بدالة مجهولة الاسم. تستدعي الدالة مجهولة الاسم التابع temperature ثم تعيد توجيه النتيجة المتحصًّل عليها.
    for _, provider := range w {
        go func(p weatherProvider) {
            k, err := p.temperature(city)
            if err != nil {
                errs <- err
                return
            }
            temps <- k
        }(provider)
    }

    sum := 0.0

    // نجمع درجات الحرارة - أو الأخطاء في حالة وجودها - من كل خِدمة 
    for i := 0; i < len(w); i++ {
        select {
        case temp := <-temps:
            sum += temp
        case err := <-errs:
            return 0, err
        }
    }

    // نُرجع الحرارة كما في السابق
    return sum / float64(len(w)), nil
}