الدليل الكامل لإدارة الحزم والوحدات

1. الوحدات وأساسيات إدارة الحزم في Go

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

مبدأ العمل

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

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

الدور في لغة Go

• التحكم في الإصدارات: تتيح لوحدات Go للمطورين تحديد استخدام إصدارات معينة من المكتبات الخارجية، مما يضمن إعادة إنتاج الكود.
• إدارة الحزم: إدارة تبعيات المشروع وإصداراتها بشكل مريح.
• عزل الوحدة: يمكن لمشاريع مختلفة الاعتماد على إصدارات مختلفة من نفس الحزمة دون صراع، حيث لكل مشروع ملف go.mod الخاص به لإدارة التبعيات.

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

2. تهيئة وحدة Go الخاصة بك

تهيئة وحدة Go الجديدة بسيطة للغاية. يمكنك تنفيذ الأمر التالي في الدليل الجذري لمشروعك:

go mod init <اسم-الوحدة>

هنا، <اسم-الوحدة> عادة ما يكون عنوان مستودع الكود، مثل github.com/اسم-المستخدم/مستودع.

الغرض من ملف go.mod

بمجرد تنفيذ أمر go mod init بنجاح، سيتم إنشاء ملف go.mod في الدليل الحالي. يحدد هذا الملف ما يلي:

• اسم الوحدة الحالية.
• إصدار Go.
• معلومات ضرورية حول جميع التبعيات المباشرة، بما في ذلك الإصدار المناسب لكل حزمة.

ملف go.mod هو المكون الأكثر أهمية في آلية الوحدات Go، وسيتم تحديثه تلقائيًا مع إضافة أو إزالة التبعيات.

3. إنشاء وهيكلة حزم Go

3.1 أساسيات إنشاء الحزم

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

لإنشاء حزمة جديدة، تحتاج إلى:

1. إنشاء مجلد لتمثيل دليل الحزمة.
2. إنشاء ملفات .go في المجلد وتحديد package <اسم-الحزمة> في السطر الأول من الملف.

اسم الحزمة عادة ما يرتبط باسم الدليل ولكن ليس من الضروري أن يكون متناسقًا. يجب أن يكون اسم الحزمة قصيرًا وواضحًا، وتجنب استخدام الشرطات.

3.2 هيكل الحزمة

توزيع حزم Go بشكل منطقي أمر ضروري لضمان قراءة الكود وصيانته وإعادة الاستخدام.

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

/الدليل-الجذري
    /pkg
        /حزمة-فرعية1
            حزمة-فرعية1.go
        /حزمة-فرعية2
            حزمة-فرعية2.go
    /cmd
        main.go  // دليل cmd لتطبيقات سطر الأوامر
    /internal
        helper.go

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

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

4.1 استيراد الحزم الداخلية

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

├── src
│   ├── main.go
│   └── mypackage
│       └── mymodule.go

في هذا المثال، mypackage هي حزمة داخلية أنشأتها، تحتوي على ملف يسمى mymodule.go. أولاً، تأكد من أن ملف mymodule.go يعلن عن الحزمة الصحيحة:

// mymodule.go
package mypackage

// SomeFunction هي دالة عامة في mypackage
func SomeFunction() {
    // تنفيذ الدالة
}

الآن، إذا أردنا استخدام SomeFunction من الحزمة mypackage في ملف main.go، نحتاج إلى استيرادها:

// main.go
package main

import (
    "fmt"
    "project/src/mypackage"
)

func main() {
    mypackage.SomeFunction()
    fmt.Println("تم استدعاء الدالة")
}

البيان import أعلاه يقوم بإستيراد حزمة mypackage إلى ملف main.go، مما يتيح لنا استدعاء الدوال من تلك الحزمة باستخدام mypackage.SomeFunction.

4.2 استخدام الحزم الخارجية

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

فلنفترض أنك ترغب في استخدام gorilla/mux في مشروعك، وهي مكتبة موجهة لطلبات HTTP شهيرة. يمكنك استيرادها واستخدامها على النحو التالي:

أولاً، قم بتثبيت الحزمة باستخدام الأمر go get:

go get -u github.com/gorilla/mux

ثم، قم بإستيراد واستخدام gorilla/mux في كودك:

package main

import (
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter() // إنشاء نسخة من الموجه
    // إضافة قواعد المسار
    r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request){
        w.Write([]byte("مرحبًا بك في gorilla/mux!"))
    })
    
    // تشغيل خادم HTTP
    http.ListenAndServe(":8000", r)
}

في الكود أعلاه، قمنا باستيراد gorilla/mux لإنشاء موجه HTTP، وتعريف دالة المعالج للمسار الجذري، وأخيراً تشغيل الخادم على المنفذ 8000 باستخدام http.ListenAndServe.

5. إدارة الاعتمادات الخاصة بالوحدات

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

5.1 تحديث الاعتماديات باستخدام go get

يمكن أن يقوم الأمر go get لا يقوم فقط بإضافة اعتماديات الحزم الجديدة ولكن أيضاً بتحديث تلك الموجودة بالفعل. وفيما يلي بعض الخيارات الشائعة لـ go get:

• تحديث حزمة واحدة:

  go get -u github.com/some/package

• تحديث كل الاعتماديات لهذه الحزمة:

  go get -u github.com/some/package/...

• تحديث كل الاعتماديات في المشروع:

  go get -u ./...

• تنزيل ولكن عدم التثبيت:

  go get -d github.com/some/package

عند تنفيذ العمليات التحديثية، ستقوم Go بتحديث الاعتماديات إلى أحدث إصدار فرعي أو تنقيحي (استنادًا إلى الإصدار البادئي)، وسيتم عكس تلك التغييرات أيضًا في ملف go.mod.

التحكم في الإصدارات وملف go.mod

منذ الإصدار 1.11، قدم لغة Go نظام إدارة تبعيات جديد يسمى "وحدات Go". في دليل المشروع الرئيسي، يسجل ملف go.mod التبعيات الخاصة بالحزم.

يتضمن ملف go.mod الأقسام التالية:

• الوحدة: تعلن مسار الوحدة للمشروع الحالي.
• تتطلب: تعلن التبعيات ونسخها الخاصة.
• استبدال: يمكن تحديد مسارات ونسخ بديلة.
• استبعاد: تُستخدم لاستبعاد نسخ محددة.

يمكن أن يكون مثالاً لملف go.mod كما يلي:

module github.com/my/awesome-project

go 1.14

require (
    github.com/gorilla/mux v1.7.4
    golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975
)

replace (
    github.com/old/dependency => github.com/new/dependency v1.2.3
)

exclude (
    github.com/old/dependency v1.1.4
)

عند تشغيل أوامر مثل go build أو go test في المشروع، ستقوم Go تلقائيًا بإنشاء أو تحديث ملف go.mod لتحديد جميع التبعيات المطلوبة للمشروع. الممارسة الأفضل في التحكم في الإصدارات هي تحديث بانتظام ملفي go.mod و go.sum (الذي يسجل القيم التشفيرية المتوقعة للتبعيات).

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