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

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

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

المتطلبات

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

إنشاء وحدة جديدة

قد تبدو الوحدة module مشابهة للحزمة package للوهلة الأولى في لغة جو، لكن تحتوي الوحدة على عدد من الشيفرات التي تُحقق وظيفة الحزمة، إضافةً إلى ملفين مهمين في المجلد الجذر root هما "go.mod" و "go.sum". تحتوي هذه الملفات على معلومات تستخدمها أداة go لتتبع إعدادات ضبط Configuration الوحدة الخاصة بك، وتجري عادةً صيانتها بواسطة الأداة نفسها، لذا لن تكون مضطرًا لفعل ذلك بنفسك.

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

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

$ mkdir projects
$ cd projects

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

أنشئ ضمن مجلد projects مجلدًا باسم "mymodule":

$ mkdir mymodule

بعد إنشاء مجلد الوحدة، ستصبح لدينا البنية التالية:

└── projects
    └── mymodule

الخطوة التالية هي إنشاء ملف "go.mod" داخل مجلد "mymodule" كي نُعّرف الوحدة، وسنستخدم لأجل ذلك الأمر go mod init ونحدد له اسم الوحدة mymodule كما يلي:

$ go mod init mymodule

يعطي هذا الأمر الخرج التالي عند إنشاء الوحدة:

go: creating new go.mod: module mymodule

سيصبح لديك الآن بنية المجلد التالية:

└── projects
    └── mymodule
        └── go.mod

دعنا نلقي نظرةً على ملف "go.mod" لمعرفة ما فعله الأمر go mod init.

الملف go.mod

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

افتح الملف go.mod الموجود ضمن المجلد mymodule باستخدام محرر نانو nano أو محرر النصوص المفضل لديك:

$ nano go.mod

ستكون محتوياته هكذا (قليلة أليس كذلك؟):

module mymodule

go 1.16

في السطر الأول لدينا موجّه يُدعى module، مهمته إخبار مُصرّف اللغة عن اسم الوحدة الخاصة بك، بحيث عندما يبحث في مسارات الاستيراد import ضمن حزمة فإنه يعرف أين عليه أن يبحث عن mymodule. تأتي القيمة mymodule من المعامل الذي مررته إلى go mod init:

module mymodule

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

go 1.16

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

لقد أنشأت الآن وحدة جو باستخدام go mod init واطلعت على ما يحتويه ملف "go.mod"، لكن ليس لهذه الوحدة أي وظيفة تفعلها حتى الآن.

سنبدأ في الخطوة التالية بتطوير هذه الوحدة وإضافة بعض الوظائف إليها.

كيفية إضافة شيفرات برمجية إلى الوحدة

ستنشئ ملف "main.go" داخل المجلد "mymodule" لنضع فيه شيفرة برمجية ونشغلها ونختبر صحة عمل الوحدة. يُعد استخدام ملف "main.go" في برامج هذه اللغة للإشارة إلى نقطة بداية البرنامج أمرًا شائعًا.

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

نُنشئ الآن ملفًا باسم "main.go" باستخدام محرّر نانو أو أي محرر نصوص مفضل لديك:

$ nano main.go

ضع التعليمات البرمجية التالية في ملف "main.go"، إذ تصرّح هذه التعليمات أولًا عن الحزمة، ثم تستورد الحزمة fmt، وتطبع رسالةً ترحيبية:

package main
import "fmt"
func main() {
    fmt.Println("Hello, Modules!")
}

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

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

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

بمجرد إنشاء ملف "main.go"، ستصبح بنية مجلد الوحدة مشابهة لما يلي:

└── projects
    └── mymodule
        └── go.mod
        └── main.go

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

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

شغّل ملف "main.go" الذي أنشأته باستخدام الأمر go run:

$ go run main.go

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

Hello, Modules!

أضفنا في هذا القسم الملف "main.go" إلى الوحدة التي أنشأناها وعرّفنا فيها نقطة دخول متمثلة بالدالة main وجعلناها تطبع عبارة ترحيبية.

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

سنوسّع في القسم التالي هذه الوحدة عن طريق إنشاء حزمة إضافية داخلها.

إضافة حزمة إلى الوحدة

قد تحتوي الوحدة على أي عدد من الحزم والحزم الفرعية sub-packages على غرار حزمة جو القياسية، وقد لا تحتوي على أية حزم. سننشئ الآن حزمة باسم mypackage داخل المجلد "mymodule". سنستخدم كما جرت العادة الأمر mkdir ونمرر له الوسيط mypackage لإنشاء مجلد جديد داخل المجلد "mymodule":

$ mkdir mypackage

سيؤدي هذا إلى إنشاء مجلد جديد باسم "mypackage" مثل حزمة فرعية جديدة من المجلد "mymodule":

└── projects
    └── mymodule
        └── mypackage
        └── main.go
        └── go.mod

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

$ cd mypackage
$ nano mypackage.go

ضِف داخل الملف "mypackage.go" الشيفرة التالية التي تتضمن دالةً تدعى PrintHello تطبع عبارة !Hello, Modules! This is mypackage speaking عند استدعائها.

package mypackage

import "fmt"

func PrintHello() {
    fmt.Println("Hello, Modules! This is mypackage speaking!")
}

نحن نريد أن تكون الدالة PrintHello متاحةً للحزم والبرامج الأخرى، لذا جعلناها دالةً مُصدّرةً exported function بكتابتنا لأول حرف منها بالحالة الكبيرة P.

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

افتح ملف "main.go" من مجلد "mymodule" واستدعِ الدالة PrintHello كما يلي:

package main

import (
    "fmt"

    "mymodule/mypackage"
)

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

    mypackage.PrintHello()
}

كما ذكرنا قبل قليل، عندما نريد استيراد الحزمة mypackage نضع اسم الوحدة قبلها مع وضع الفاصل / بينهما، وهو نفسه اسم الوحدة الذي وضعته في ملف "go.mod" (أي mymodule).

"mymodule/mypackage"

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

شغّل الوحدة مرةً أخرى بعد إجراء التعديلات عليها باستخدام الأمر go run ومرر اسم الملف "main.go" الموجود ضمن المجلد "mymodule" كما في السابق:

$ go run main.go

عند التشغيل سترى نفس الرسالة التي حصلنا عليها سابقًا والمتمثلة بالرسالة !Hello, Modules إضافةً إلى الرسالة المطبوعة من دالة PrintHello والموجودة في الحزمة الجديدة التي أضفناها:

Hello, Modules!
Hello, Modules! This is mypackage speaking!

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

سنضيف في القسم التالي وحدةً بعيدة (من غيت Git) مثل اعتمادية لوحدتك.

تضمين وحدة بعيدة أنشأها آخرون في وحدتك

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

سنضيف في المثال التالي المكتبة cobra مثل اعتمادية للوحدة التي أنشأناها، وهي مكتبة شائعة لإنشاء تطبيقات الطرفية Console.

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

شغّل الأمر go get من داخل مجلد "mymodule":

$ go get github.com/spf13/cobra

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

افتح ملف "go.mod" الموجود في المجلد "mymodule" لترى كيف حدّثت أداة go ملف "go.mod" عند إضافة الاعتمادية الجديدة. قد يتغير المثال أدناه اعتمادًا على الإصدار الحالي من Cobra أو إصدار أداة go التي تستخدمها، ولكن يجب أن تكون البنية العامة للتغييرات متشابهة:

module mymodule

go 1.16

require (
    github.com/inconshreveable/mousetrap v1.0.0 // indirect
    github.com/spf13/cobra v1.2.1 // indirect
    github.com/spf13/pflag v1.0.5 // indirect
)

لاحظ إضافة قسم جديد مُتمثّل بالموجّه require، ومهمته إخبار مُصرّف اللغة عن الوحدة التي تريدها (في حالتنا هي github.com/spf13/cobra) وعن إصدارها أيضًا. نلاحظ أيضًا أن هناك تعليق مكتوب فيه indirect، ليوضح أنه في الوقت الذي أُضيف فيه الموجّه require، لم تكن هناك إشارة مباشرة إلى الوحدة في أي من ملفات المصدر الخاصة بالوحدة. نلاحظ أيضًا وجود بعض الأسطر في require تشير إلى وحدات أخرى تتطلبها المكتبة Cobra والتي يجب على أداة جو أن تشير إليها أيضًا.

نلاحظ أيضًا أنه عند تشغيل الأمر go run أُنشئ ملف جديد باسم "go.sum" في مجلد "mymodule"، وهو ملفٌ آخر مهم لوحدات جو يحتوي على معلومات تستخدمها جو لتسجيل قيم معمّاة hashes وإصدارات معينة من الاعتماديات. يضمن هذا تناسق الاعتماديات، حتى لو ثُبتت على جهاز مختلف.

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

افتح الملف "main.go" الموجود في المجلد "mymodule" وضع فيه المحتويات التالية:

package main

import (
    "fmt"

    "github.com/spf13/cobra"

    "mymodule/mypackage"
)

func main() {
    cmd := &cobra.Command{
        Run: func(cmd *cobra.Command, args []string) {
            fmt.Println("Hello, Modules!")

            mypackage.PrintHello()
        },
    }

    fmt.Println("Calling cmd.Execute()!")
    cmd.Execute()
}

تُنشئ هذه الشيفرة بنية cobra.Command مع دالة Run تطبع عبارة ترحيب، والتي ستُنفّذ بعد ذلك باستدعاء ()cmd.Execute.

شغّل الشيفرة الآن بعد أن عدلناها:

$ go run main.go

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

Calling cmd.Execute()!
Hello, Modules!
Hello, Modules! This is mypackage speaking!

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

استخدام إصدار محدد من وحدة

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

$ go get github.com/spf13/cobra@latest

تخيل الآن أن هناك وحدة تستخدمها، وهي قيد التطوير حاليًا، ولنفترض اسمها your_domain/sammy/awesome. افترض أن هناك ميزة أضيفت إلى هذه الوحدة في فرع اسمه new-feature. لإضافة هذا الفرع مثل اعتمادية للوحدة الخاصة بك، يمكنك ببساطة استخدام مسار الوحدة متبوعًا بالرمز @ متبوعًا باسم الفرع:

$ go get your_domain/sammy/awesome@new-feature

عند تشغيل هذا الأمر ستتصل أداة go بالمستودع your_domain/sammy/awesome، وستنزّل الفرع new-features من آخر إيداع، وتضيف هذه المعلومات إلى الملف "go.mod".

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

بالعودة إلى نفس المثال السابق، افترض أنك بحاجة إلى الإشارة إلى الإيداع 07445ea من github.com/spf13/cobra لأنه يحتوي على بعض التغييرات التي تحتاجها ولا يمكنك استخدام إصدار آخر لسبب ما. في هذه الحالة، يمكنك وضع قيمة معمّاة hash بعد الرمز @.

شغّل الآن الأمر go get من داخل مجلد "mymodule" لتنزيل الإصدار الجديد:

$ go get github.com/spf13/cobra@07445ea

إذا فتحت الآن ملف "go.mod" الخاص بالوحدة، فسترى أن go get قد حدّث سطر require للإشارة إلى الإيداع الذي تستخدمه:

module mymodule

go 1.16

require (
    github.com/inconshreveable/mousetrap v1.0.0 // indirect
    github.com/spf13/cobra v1.1.2-0.20210209210842-07445ea179fc // indirect
    github.com/spf13/pflag v1.0.5 // indirect
)

على عكس الوسوم أو الفروع، ونظرًا لأن الإيداع يمثّل نقطةً زمنيةً معينة، تتضمن جو معلومات إضافية في موجّه require للتأكد من استخدام الإصدار الصحيح مستقبلًا؛ فإذا نظرت إلى الإصدار، سترى أنه يتضمن إيداعًا معمّى hash قد أضفته، أي v1.1.2-0.20210209210842-07445ea179fc.

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

بالعودة إلى نفس المثال Cobra السابق، ولنفترض أنك بحاجة إلى استخدام الإصدار 1.1.1، الذي يملك وسمًا يدعى v1.1.1 في مستودع Cobra.

سنستخدم الأمر go get مع الرمز @ حتى نتمكن من استخدام هذا الإصدار الموسوم تمامًا كما فعلنا مع الفروع أو الوسوم التي لا تشير لإصدار non-version tag. الآن، حدّث الوحدة الخاصة بك حتى تستخدم Cobra 1.1.1 من خلال تشغيل الأمر go get مع رقم الإصدار v1.1.1:

$ go get github.com/spf13/cobra@v1.1.1

إذا فتحت الآن ملف "go.mod" الخاص بالوحدة، فسترى أن go get قد حدّث سطرrequire للإشارة إلى الإيداع الذي تستخدمه:

module mymodule

go 1.16

require (
    github.com/inconshreveable/mousetrap v1.0.0 // indirect
    github.com/spf13/cobra v1.1.1 // indirect
    github.com/spf13/pflag v1.0.5 // indirect
)

أخيرًا، إذا كنت تستخدم إصدارًا محددًا من المكتبة، مثل الإيداع 07445ea أو الإصدار v1.1.1 الذين تعرفنا عليهما منذ قليل، ثم قررت استخدام أحدث إصدار من المكتبة، فمن الممكن إنجاز ذلك باستخدام latest كما ذكرنا سابقًا.

لتحديث الوحدة الخاصة بك إلى أحدث إصدار من Cobra، استخدم الأمر go get مرةً أخرى مع مسار الوحدة وتحديد الإصدار latest بعد الرمز @:

$ go get github.com/spf13/cobra@latest

بعد تنفيذ هذا الأمر، يُحدّث ملف "go.mod" ليبدو كما كان عليه عند تنزيل المكتبة Cobra أول مرة. قد يبدو الخرج مختلفًا قليلًا بحسب إصدار جو الذي تستخدمه والإصدار الأخير من Cobra ولكن يُفترض أن تلاحظ أن السطر github.com/spf13/cobra في قسم require قد تحدّث إلى آخر إصدار:

module mymodule

go 1.16

require (
    github.com/inconshreveable/mousetrap v1.0.0 // indirect
    github.com/spf13/cobra v1.2.1 // indirect
    github.com/spf13/pflag v1.0.5 // indirect
)

يُعد الأمر go get أداةً قوية يمكنك استخدامها لإدارة الاعتماديات في ملف "go.mod" دون الحاجة إلى تحريره يدويًا. يتيح لك استخدام الرمز @ مع اسم الوحدة، أن تستخدم إصدارات معينة لوحدة ما، أو حتى إيداعات، أو فروع، أو الرجوع إلى أحدث إصدار من اعتمادياتك كما رأينا للتو. سيسمح استخدام مجموعة الأدوات التي تعرفنا عليها في هذه المقالة بضمان استقرار البرنامج مستقبلًا.

الخاتمة

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

ترجمة -وبتصرف- للمقال How to Use Go Modules لصاحبه Gopher Guides.

اقرأ أيضًا

• المقال السابق: كيفية استخدام الحزمة Flag في لغة جو Go
• كتابة أول برنامج (ومكتبة) لك باستخدام لغة البرمجة Go
• استيراد الحزم في لغة جو Go
• بناء البرامج المكتوبة بلغة جو Go وتثبيتها