بناء البرامج المكتوبة بلغة جو Go وتثبيتها

استخدمنا خلال هذه السلسلة البرمجة بلغة GO الأمر go run كثيرًا، وكان الهدف منه تشغيل شيفرة البرنامج الخاص بنا، إذ أنه يُصرّف شفرة المصدر تلقائيًا ويُشغّل الملف التنفيذي الناتج أي القابل للتنفيذ executable. يُعد هذا الأمر مفيدًا عندما تحتاج إلى اختبار برنامجك من خلال سطر الأوامر command line، لكن عندما ترغب بنشر تطبيقك، سيتطلب منك ذلك بناء تعليماتك البرمجية في ملف تنفيذي، أو ملف واحد يحتوي على شيفرة محمولة أو تنفيذية (يُطلق عليه أيضًا الكود-باء p-code، وهو شكل من أشكال مجموعة التعليمات المصممة للتنفيذ الفعّال بواسطة مُصرّف برمجي) يمكنها تشغيل تطبيقك. يمكنك لإنجاز ذلك استخدام سلسلة أدوات جو لبناء البرنامج وتثبيته.

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

ستتعلم في هذا المقال كيفية استخدام سلسلة أدوات لغة جو Go toolchain لتشغيل وبناء وتثبيت برنامج "!Hello، World" لفهم كيفية استخدام التطبيقات البرمجية وتوزيعها ونشرها بفعالية.

المتطلبات

أن يكون لديك مساحة عمل خاصة في لغة جو، وإذا لم يكن لديك ذلك اتبع سلسلة المقالات التالية، فقد تحدّثنا عن ذلك في بداية السلسلة "البرمجة بلغة Go:

إعداد وتشغيل جو التنفيذي Go Binary

سننشئ بدايةً تطبيقًا بسيطًا بلغة جو يطبع العبارة الترحيبية "!Hello، World"، وذلك لتوضيح سلسلة أدوات جو، وانظر مقال كتابة برنامجك الأول في جو Go إن لم تتطلع عليه مسبقًا.

أنشئ مجلد "greeter" داخل المجلد "src":

$ mkdir greeter

بعد ذلك أنشئ ملف "main.go" بعد الانتقال إلى هذا المجلد الذي أنشأته للتو، ويمكنك استخدام أي محرر نصوص تختاره ﻹنشاء الملف، هنا استخدمنا محرر نانو nano:

$ cd greeter
$ nano main.go

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

package main

import "fmt"

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

عند تشغيل هذا البرنامج سيطبع العبارة "!Hello, World" ثم سينتهي البرنامج. احفظ الملف الآن واغلقه.

استخدم الأمر go run لاختبار البرنامج:

$ go run main.go

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

Hello, World!

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

إنشاء وحدة جو من أجل Go binary

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

$ go mod init greeter

سيؤدي ذلك إلى إنشاء الملف go.mod الذي يتضمن اسم الوحدة ونسخة جو المستخدمة في إنشائها.

go: creating new go.mod: module greeter
go: to add module requirements and sums:
    go mod tidy

سيطالبك جو بتشغيل go mod tidy لتحديث متطلبات هذه الوحدة إذا تغيرت في المستقبل، ولن يكون لتشغيله الآن أي تأثير إضافي.

بناء الملفات التنفيذية باستخدام الأمر go build

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

سنجرب ذلك مع ملف main.go. من داخل المجلد greeter من خلال تنفيذ الأمر التالي:

$ go build

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

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

$ ls

إذا كنت تستخدم نظام ماك أو إس macOS أو لينكس Linux، فستجد ملفًا تنفيذيًا جديدًا مُسمّى على اسم المجلد الذي بنيت فيه برنامجك:

greeter  main.go  go.mod

ملاحظة: في نظام التشغيل ويندوز، سيكون الملف التنفيذي باسم "greeter.exe".

سيُنشئ الأمرgo build افتراضيًا ملفًا تنفيذيًا للنظام الأساسي والمعمارية الحاليين. على سبيل المثال، إذا بُنيَ على نظام تشغيل linux / 386، سيكون الملف التنفيذي متوافقًا مع أي نظام Linux / 386 آخر، حتى إذا لم يكن جو مُثبّتًا على ذلك النظام. تدعم لغة جو إمكانية البناء على الأنظمة والمعماريات الأخرى.

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

$ ./greeter

أما في ويندوز نفّذ الأمر:

$ greeter.exe

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

Hello, World!

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

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

تغيير اسم الملف التنفيذي

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

يقرر جو تلقائيًا اسم الملف التنفيذي الذي بُنيَ عند تشغيل الأمر go build، وذلك اعتمادًا على الوحدة التي أنشأتها. عندما نفّذنا الأمر go mod init greeter منذ قليل، أُنشئت وحدة باسم greeter، وهذا هو سبب تسمية الملف التنفيذي الثنائي binary الذي أُنشئ باسم "greeter" بدوره.

إذا فتحت ملف go.mod (الذي يُفترض أن يكون ضمن مجلد مشروعك)، وكان يتضمن التصريح التالي:

module github.com/sammy/shark

وهذا يعني أن الاسم الافتراضي للملف التنفيذي الذي بُنيَ هو shark.

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

سنغيّر الآن اسم الملف التنفيذي الذي أنشأناه في القسم السابق إلى الاسم "hello" ونضعه في مجلد فرعي يسمى "bin". لن نحتاج إلى إنشاء هذا المجلد (bin)، إذ ستتكفل جو بذلك أثناء عملية البناء. نفّذ الأمر go build مع الرايةo-:

$ go build -o bin/hello

تُخبر الراية o- مُصرّف جو أن عليه مُطابقة خرج الأمر go build مع الوسيط المُحدد بعدها والمتمثّل بالعبارة bin/hello. بعبارةٍ أوضح؛ تُخبر هذه الراية المُصرّف أن الملف التنفيذي السابق يجب أن يكون اسمه "hello" وأن يكون ضمن مجلد اسمه "bin"، وفي حال لم يكن هذا المجلد موجودًا فعليك إنشاؤه تلقائيًّا.

لاختبار الملف التنفيذي الجديد، انتقل إلى المجلد الجديد وشغّل الملف التنفيذي:

$ cd bin
$ ./hello

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

Hello, World!

يمكنك الآن اختيار اسم الملف التنفيذي ليناسب احتياجات مشروعك.

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

تثبيت برامج جو باستخدام الأمر go install

ناقشنا حتى الآن كيفية إنشاء ملفات تنفيذية من ملفات مصدرية بامتداد "go."، هذه الملفات التنفيذية مفيدة من أجل التوزيع والنشر والاختبار، ولكن لا يمكن تنفيذها من خارج المجلدات المصدرية الموجودة ضمنها. قد تكون هذه مشكلة إذا كنت تريد استخدام برنامجك باستمرار ضمن سكريبتات الصدفة shell scripts أو في مهام أخرى. لتسهيل استخدام البرامج، يمكنك تثبيتها في نظامك والوصول إليها من أي مكان. لتوضيح الفكرة سنستخدم الأمر go install لتثبيت البرنامج الذي نعمل عليه.

يعمل الأمر go install على نحوٍ مماثل تقريبًا للأمر go build، ولكن بدلًا من ترك الملف التنفيذي في المجلد الحالي أو مجلد محدد بواسطة الراية o-، فإنه يضعه في المجلد "GOPATH/bin$".

لمعرفة مكان وجود مجلد "GOPATH$" الخاص بك، شغّل الأمر التالي:

$ go env GOPATH

قد يختلف الخرج الذي تتلقاه، ولكن يُفترض أن يكون ضمن مجلد go الموجود داخل مجلد HOME$:

$HOME/go

نظرًا لأن go install سيضع الملفات التنفيذية التي أُنشئت في مجلد فرعي للمجلد GOPATH$ اسمه bin، يجب إضافة هذا المجلد إلى متغير البيئة PATH$. تحدّثنا عن هذه المواضيع في مقالة كيفية تثبيت جو وإعداد بيئة برمجة محلية.

بعد إعداد المجلد GOPATH/bin$، ارجع إلى مجلد greeter:

$ cd ..

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

$ go install

سيؤدي هذا إلى بناء ملفك التنفيذي ووضعه في GOPATH/bin$. شغّل الأمر التالي لاختبار ذلك:

$ ls $GOPATH/bin

سيسرد لك هذا الأمر محتويات المجلد GOPATH/bin$:

greeter

ملاحظة: لا يدعم الأمر go install الراية o-، لذلك سيستخدم الاسم الافتراضي الذي تحدّثنا عنه سابقًا لتسمية الملف التنفيذي.

تحقق الآن ما إذا كان البرنامج سيعمل من خارج المجلد المصدر. ارجع أولًا إلى المجلد HOME:

$ cd $HOME

استخدم ما يلي لتشغيل البرنامج:

$ greeter

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

Hello, World!

يمكنك الآن تثبيت البرامج التي تكتبها في نظامك، مما يتيح لك استخدامها من أي مكان، ومتى احتجت إليها.

خاتمة

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

استخدمنا أيضًا الأمر go install لبناء برامجنا وتثبيتها تلقائيًا مثل ملفات تنفيذية ضمن متغير البيئة PATH$ الخاص بالنظام. ستستطيع من خلال الأمرين go install و go build مشاركة واستخدام التطبيق الخاص بك كما تشاء.

الآن بعد أن تعرفت على أساسيات go build، يمكنك استكشاف كيفية إنشاء شيفرة مصدر معيارية من خلال المقالة استخدام وسوم البناء لتخصيص الملفات التنفيذية في لغة جو Go.

ترجمة -وبتصرف- للمقال How To Build and Install GOPrograms لصاحبه Gopher Guides.