كتابة تطبيقات CLI مع Go

مقدمة إلى تطبيقات Go و CLI

Go ، المعروفة أيضًا باسم Golang ، هي لغة برمجة مفتوحة المصدر صممتها Google. إنه يؤكد على البساطة والأمان والأداء ، مما يجعله خيارًا ممتازًا لإنشاء تطبيقات واجهة سطر الأوامر (CLI). تطبيقات CLI هي أدوات يمكن للمستخدمين التفاعل معها من خلال واجهة نصية ، تُستخدم بشكل شائع لإدارة النظام والأتمتة ومهام البرمجة النصية. Go مناسب تمامًا لتطوير CLI لأنه يوفر:

1. البساطة: إن بناء جملة Go سهل الفهم والكتابة ، مما يسمح للمطورين ببناء تطبيقات CLI وصيانتها بسرعة.
2. الأداء: Go هي لغة مترجمة ومكتوبة بشكل ثابت ، مما يعني أنها تنتج ملفات ثنائية محسنة ، مما ينتج عنه تطبيقات CLI سريعة وفعالة.
3. دعم التزامن: يتميز Go بأساسيات التزامن مضمنة ، مثل goroutines والقنوات ، مما يتيح معالجة متوازية سلسة وتطبيقات CLI أسرع وأكثر استجابة في النهاية.
4. تجميع ثنائي ثابت: يقوم Go بتجميع التطبيقات في ثنائي واحد مستقل - واحد بدون تبعيات خارجية - مما يسهل توزيع تطبيق CLI الخاص بك ونشره.
5. مكتبة قياسية قوية: توفر مكتبة Go القياسية العديد من الحزم المضمنة ، وتبسيط مهام تطوير CLI الشائعة ، مثل العمل مع الملفات ، والشبكات ، والتعامل مع وسيطات سطر الأوامر.

في هذه المقالة ، ستتعرف على أساسيات تطوير تطبيقات CLI باستخدام Go - بدءًا من إعداد بيئتك وتنظيم تطبيقك إلى التعامل مع وسيطات سطر الأوامر والاستفادة من حزم الجهات الخارجية.

الشروع في العمل: تثبيت Go وإعداد البيئة الخاصة بك

قبل أن تتمكن من البدء في كتابة تطبيقات CLI باستخدام Go ، يجب عليك أولاً تثبيت لغة برمجة Go على نظامك.

1. قم بزيارة صفحة تنزيل Go الرسمية ، وحدد الحزمة الثنائية المناسبة لمنصتك (Windows ، أو macOS ، أو Linux) ، واتبع تعليمات التثبيت.
2. بمجرد اكتمال التثبيت ، تحقق من تثبيت Go بشكل صحيح عن طريق تشغيل go version في جهازك الطرفي. يجب أن يعرض هذا الأمر إصدار Go المثبت.
3. قم بتكوين متغيرات البيئة الضرورية لـ Go ، بما في ذلك GOPATH ، التي تحدد موقع مساحة عمل Go (حيث سيتم تخزين مشاريع Go وتبعياتها) ، و GOROOT ، التي تشير إلى دليل تثبيت Go.
4. تأكد من أن الأمر go موجود في متغير PATH لنظامك. هذا يسمح لك بتنفيذ أوامر Go من أي دليل.

مع تثبيت Go وتهيئة بيئتك ، فأنت على استعداد لبدء إنشاء أول تطبيق CLI لك.

هيكلة تطبيق CLI الخاص بك: الحزم والوحدات

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

الحزم: الحزم هي طريقة Go لتنظيم وتجزئة الكود. تتكون الحزمة من ملف مصدر واحد أو أكثر (بامتداد .go ) موجود في نفس الدليل. يجب أن يعلن كل ملف في الحزمة عن اسم الحزمة الخاص به ، المحدد بالكلمة الأساسية package في بداية الملف. يحتوي تطبيق Go CLI النموذجي على حزمتين على الأقل:

1. main : هذه هي الحزمة الافتراضية لنقطة دخول التطبيق الخاص بك. إنه المكان الذي توجد فيه الوظيفة main() وتعمل كنقطة انطلاق لتطبيق CLI الخاص بك. يجب وضع كل أوامر وأوامر CLI الخاصة داخل الحزمة الرئيسية.
2. internal أو pkg : تحتوي هذه الحزم على كود قابل لإعادة الاستخدام ومنفصل عن منطق CLI الخاص بك. يمكنك استخدام التعليمات البرمجية internal التي يجب استيرادها فقط من خلال كود Go الخاص بك داخل المشروع ، و pkg للرمز الذي يمكن استيراده بواسطة أي مشروع Go.

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

 go mod init your.module.name

يُنشئ هذا الأمر ملف go.mod في الدليل الجذر ، والذي يسرد تبعيات مشروعك ، وملف go.sum ، الذي يحتوي على مجاميع اختبارية لكل تبعية. عند استيراد الحزم أو استخدام مكتبات الجهات الخارجية ، سيتعقب Go تلقائيًا التبعيات في ملفات go.mod و go.sum .

مصدر الصورة: لغة البرمجة Go

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

وسيطات سطر الأوامر والأعلام

تعد وسيطات وسطر الأوامر مكونات أساسية لتطبيقات CLI ، مما يسمح للمستخدمين بالتحكم في سلوك التطبيق وتوفير المدخلات اللازمة. في Go ، يمكنك العمل مع وسيطات سطر الأوامر والعلامات باستخدام flag المكتبة القياسي وحزم os.Args .

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

باستخدام نظام التشغيل OS.Args

توفر الحزمة os.Args وصولاً مباشرًا إلى وسيطات سطر الأوامر. وهي عبارة عن شريحة من السلاسل النصية ، حيث يمثل os.Args[0] اسم البرنامج قيد التشغيل ، وتمثل بقية الإدخالات الوسائط التي تم تمريرها إلى البرنامج.

فيما يلي مثال على استخدام os.Args :

 الحزمة الرئيسية

يستورد (
	"FMT"
	"نظام التشغيل"
)

func main () {
	argCount: = len (os.Args)
	fmt.Printf ("عدد الوسائط:٪ d \ n" ، argCount)
	fmt.Println ("Arguments:"، os.Args)
}

من خلال تشغيل البرنامج ، سترى الرقم وقائمة الوسائط المتوفرة.

استخدام حزمة العلم

تعد حزمة flag طريقة أكثر تعقيدًا ومرونة للعمل مع أعلام سطر الأوامر. يمكّنك من تحديد الأعلام بأنواع بيانات مختلفة وتحليل المدخلات بشكل ملائم.

فيما يلي مثال على استخدام حزمة flag :

 الحزمة الرئيسية

يستورد (
	"علَم"
	"FMT"
)

func main () {
	فار (
		سلسلة الاسم
		كثافة العمليات العمر
		ارتفاع تعويم 64
	)

	flag.StringVar (& name، "name"، "John Doe"، "Your name")
	flag.IntVar (& age، "age"، 21، "your age")
	flag.Float64Var (& height ، "height" ، 180.0 ، "طولك (بالسنتيمتر)")

	flag.Parse ()

	fmt.Printf ("الاسم:٪ s \ n" ، الاسم)
	fmt.Printf ("العمر:٪ d \ n" ، العمر)
	fmt.Printf ("الارتفاع:٪ .1f \ n" ، الارتفاع)
}

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

إنشاء أوامر وأوامر فرعية

بالنسبة لتطبيقات CLI المعقدة ، قد ترغب في إنشاء أوامر وأوامر فرعية لتنظيم وظائفك وخياراتك بشكل أفضل. إحدى الحزم الشائعة التابعة لجهة خارجية للعمل مع الأوامر والأوامر الفرعية في Go هي github.com/spf13/cobra .

الشروع في العمل مع كوبرا

للبدء ، ستحتاج إلى تثبيت حزمة Cobra:

 اذهب get -u github.com/spf13/cobra/cobra

بمجرد التثبيت ، يمكنك إنشاء تطبيق CLI جديد باستخدام Cobra:

 cobra init my-cli --pkg-name = my-cli

يقوم هذا الأمر بإنشاء دليل جديد يسمى my-cli مع البنية والملفات اللازمة لتطبيق CLI المستند إلى Cobra.

تحديد الأوامر

في تطبيق يستند إلى Cobra ، يمكنك إنشاء أوامر عن طريق تحديد مثيلات cobra.Command . يحتوي كل أمر على حقل Use (يشير إلى كيفية استخدام الأمر) ، وحقل Short (يوفر وصفًا موجزًا) ، وحقل Long (يوفر وصفًا أكثر تفصيلاً).

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

فيما يلي مثال على إنشاء أمر "تحية" بسيط:

 reetCmd: = & cobra.Command {
	استخدم: "تحية" ،
	قصير: "تحية شخص ما" ،
	طويل: "يرحب هذا الأمر بشخص ما برسالة قابلة للتخصيص." ،
	Run: func (cmd * cobra.Command، args [] string) {
		// منطق أمر الترحيب
	} ،
}

لإنشاء أمر فرعي ، يمكنك تحديد مثيل cobra.Command آخر وإضافته باعتباره تابعًا للأمر الأصل باستخدام طريقة AddCommand . على سبيل المثال ، يمكنك إنشاء أمر فرعي "goodbye" تحت أمر "الترحيب":

 goodbyeCmd: = & cobra.Command {
	استخدم: "وداعا" ،
	باختصار: "قل وداعا لشخص ما" ،
	طويل: "هذا الأمر الفرعي يقول وداعًا لشخص ما بلغة معينة." ،
	Run: func (cmd * cobra.Command، args [] string) {
		// المنطق لأمر الوداع الفرعي
	} ،
}
ترحيب Cmd.AddCommand (وداعًا Cmd)

موجهات تفاعلية وإدخال المستخدم

يمكن للمطالبات التفاعلية تحسين تجربة مستخدم تطبيق CLI الخاص بك من خلال توجيه المستخدمين من خلال سلسلة من الأسئلة وجمع المدخلات بناءً على إجاباتهم. إحدى حزم الجهات الخارجية الشائعة للعمل مع المطالبات التفاعلية في Go هي github.com/AlecAivazis/survey/v2 .

الشروع في الاستبيان

أولاً ، تحتاج إلى تثبيت حزمة الاستبيان:

 اذهب get -u github.com/AlecAivazis/survey/v2

استخدام المسح للموجهات التفاعلية

يوفر الاستطلاع مجموعة من أنواع المطالبات المحددة مسبقًا ، بما في ذلك Input Select MultiSelect Confirm والمزيد. لإنشاء مطالبة ، يمكنك إنشاء مثيل لنوع المطالبة المطلوب واستدعاء survey.Ask .

 الحزمة الرئيسية

يستورد (
	"FMT"
	"github.com/AlecAivazis/survey/v2"
)

func main () {
	سلسلة اسم فار
	namePrompt: = & Survey.Input {
		الرسالة: "ما اسمك؟" ،
	}
	يخطئ: = Survey.Ask ([] * Survey.Question {{
		اسم اسم"،
		موجه: namePrompt،
		التحقق من صحة: المسح.
	}}، &اسم)
	إذا أخطأت! = لا شيء {
		fmt.Println ("خطأ:" ، يخطئ)
		يعود
	}
	fmt.Printf ("اسم مرحبًا ،٪ s! \ n")
}

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

العمل مع المكتبات الخارجية

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

1. تهيئة وحدة Go: في الدليل الجذر لتطبيق CLI الخاص بك ، قم بتشغيل الأمر go mod init <module-name> ، مع استبدال '<module-name>' باسم الوحدة التي تريدها. سينشئ هذا الأمر ملفًا جديدًا باسم go.mod في دليل المشروع.
2. إضافة مكتبات خارجية: متى أردت استيراد مكتبة خارجية ، أضف عبارات الاستيراد الضرورية في التعليمات البرمجية المصدر. في المرة الأولى التي تنشئ فيها مشروعك أو تشغله ، سيقوم Go تلقائيًا بتنزيل الإصدارات المطلوبة من هذه المكتبات وتثبيتها ، وتحديث ملفات go.mod و go.sum .
3. تحديث المكتبات: لتحديث مكتبة خارجية ، يمكنك استخدام الأمر go get -u متبوعًا باسم الحزمة. يقوم هذا بتحديث الحزمة إلى أحدث إصدار ، مما يعكس التغييرات في ملف go.mod الخاص بك.
4. إزالة المكتبات غير المستخدمة: لتنظيف المكتبات غير المستخدمة من ملف go.mod ، قم بتشغيل الأمر go mod tidy . يؤدي هذا إلى إزالة أي مكتبات لم تعد مطلوبة أو أصبحت قديمة أثناء التطوير.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

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

معالجة الأخطاء والتسجيل

تعتبر معالجة الأخطاء وتسجيلها بشكل صحيح أمرًا بالغ الأهمية لضمان متانة تطبيق CLI الخاص بك. تقدم Go نهجًا عمليًا ومريحًا للغاية للعمل مع الأخطاء والسجلات. للتعامل مع الأخطاء في Go ، يمكنك استخدام حزمة errors القياسية. فيما يلي بعض أفضل الممارسات عند التعامل مع الأخطاء في تطبيقات CLI الخاصة بك:

• إرجاع الأخطاء بدلاً من الذعر: بدلاً من التسبب في ذعر تطبيقك وتعطله ، قم بإرجاع الأخطاء من الوظائف والتعامل معها بشكل مناسب. وهذا يسمح بتحكم أفضل في التدفق وآليات الاسترداد في تطبيق CLI الخاص بك.
• استخدام أنواع الأخطاء المخصصة: قم بإنشاء أنواع الأخطاء الخاصة بك باستخدام errors.New وظيفة جديدة أو عن طريق تنفيذ واجهة error . تمكنك أنواع الأخطاء المخصصة من نقل معلومات أكثر تحديدًا حول الخطأ الذي حدث عند حدوث خطأ.
• معالجة الأخطاء بالقرب من المصدر: كلما أمكن ، تعامل مع الأخطاء بأقرب ما يمكنك من أصلها. يساعد ذلك في الحفاظ على بساطة شفرتك ويسهل التفكير في معالجة الأخطاء في المواقف المعقدة.

للتسجيل ، تقدم مكتبة Go القياسية حزمة log ، والتي توفر واجهة تسجيل بسيطة ومرنة. يمكنك استخدام الحزمة لتسجيل الرسائل بمستويات خطورة مختلفة وتخصيص هدف الإخراج. لمزيد من إمكانات التسجيل المتقدمة ، ضع في اعتبارك استخدام التسجيل المنظم مع الحزمة الشهيرة github.com/sirupsen/logrus . فيما يلي بعض النصائح للتسجيل الفعال في تطبيق CLI الخاص بك:

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

اختبار وقياس تطبيقات CLI

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

• إنشاء وظائف الاختبار: اكتب وظائف الاختبار لمكونات تطبيق CLI وابدأها بـ Test ، مثل TestMyFunction . ضع هذه الوظائف في ملف _test.go منفصل بجانب الملف المصدر الذي يتم اختباره.
• استخدام جداول الاختبار: استخدم جداول الاختبار (المعروفة أيضًا باسم الاختبارات المعتمدة على الجدول) لاختبار مجموعات متعددة من المدخلات والمخرجات باستخدام وظيفة اختبار واحدة. يبسط هذا الأسلوب كود الاختبار الخاص بك ويجعله أكثر قابلية للصيانة.
• قم بتشغيل الاختبارات بالتوازي: استفد من وظيفة t.Parallel() داخل وظائف الاختبار لتشغيل الاختبارات بشكل متزامن. يمكن أن يؤدي ذلك إلى تسريع تنفيذ مجموعة الاختبار الخاصة بك ، خاصة عند التعامل مع الاختبارات كثيفة الاستخدام للموارد.
• إنشاء تقارير تغطية الاختبار: استخدم الأمر go test -cover لإنشاء تقارير تغطية الكود. يساعدك هذا في تحديد مناطق التعليمات البرمجية الخاصة بك التي تتطلب اختبارًا أكثر شمولاً ويضمن درجة أعلى من تغطية الاختبار.

لقياس أداء مكونات تطبيق CLI الخاص بك ، يوفر Go دعمًا لقياس الأداء من خلال نفس حزمة testing . استخدم المعايير على النحو التالي:

• إنشاء وظائف معيارية: اكتب وظائف معيارية وابدأها بـ Benchmark ، مثل BenchmarkMyFunction . ضع هذه الوظائف في نفس ملف _test.go الذي يحتوي على وظائف الاختبار ذات الصلة.
• استخدم معلمة testing.B : قم بتشغيل الكود الذي تريد قياسه داخل حلقة يتم التحكم فيها بواسطة معلمة testing.B (على سبيل المثال ، for i := 0; i < bN; i++ { ... } ). يتم ضبط معلمة testing.B تلقائيًا بواسطة حزمة testing لتحقيق قياس ذو دلالة إحصائية.
• تحليل نتائج قياس الأداء: استخدم الأمر go test -bench لتشغيل المعايير الخاصة بك وتحليل النتائج. يمكن أن يساعدك ذلك في تحديد مجالات تطبيق CLI الخاص بك التي تحتاج إلى تحسين وقياس تأثير تحسينات الأداء.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

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

نشر وتوزيع تطبيق CLI الخاص بك

بمجرد الانتهاء من تطوير تطبيق Command Line Interface (CLI) الخاص بك في Go ، فإن الخطوة الأخيرة هي نشره وتوزيعه للمستخدمين للوصول إليه والاستفادة منه. تتيح لك لغة البرمجة Go وسلسلة أدوات الإنشاء الخاصة بها إنشاء ملفات تنفيذية مستقلة مرتبطة بشكل ثابت يسهل توزيعها ومشاركتها عبر الأنظمة الأساسية.

بناء الملف التنفيذي

لإنشاء تطبيق Go CLI ، استخدم الأمر go build متبوعًا بالحزمة أو الملف الهدف:

 go build ./path/to/your/package

أو:

 go build main.go

سيقوم هذا الأمر بإنشاء ملف ثنائي قابل للتنفيذ لمنصتك الحالية (على سبيل المثال ، Windows و macOS و Linux) ووضعه في دليل العمل الحالي. افتراضيًا ، يتطابق اسم الملف الثنائي مع اسم الحزمة أو اسم الملف المصدر بدون الامتداد (على سبيل المثال ، main ).

ومع ذلك ، يمكنك تحديد أسماء الملفات الثنائية الناتجة واستهداف أنظمة أساسية مختلفة باستخدام علامة -o ومتغيرات البيئة:

 GOOS=linux GOARCH=amd64 go build -o custom-name ./path/to/your/package

في المثال أعلاه ، قمنا بتعيين متغيرات بيئة GOOS و GOARCH لتوجيه عملية إنشاء Go لاستهداف Linux بهندسة AMD64 ، وقمنا بتعيين اسم الملف الثنائي الناتج على custom-name .

الترجمة المتقاطعة لمنصات مختلفة

يعمل Go على تبسيط الترجمة المتقاطعة ، ويمكنك إنشاء ملفات تنفيذية بسرعة لأنظمة أساسية مختلفة بدون تكوينات بناء معقدة. لتجميع تطبيق Go CLI الخاص بك لأنظمة أساسية متعددة ، قم بتعيين متغيرات بيئة GOOS و GOARCH وفقًا لذلك. يوضح المثال التالي كيفية ترجمة تطبيق Go CLI لأنظمة Windows و macOS و Linux:

 # For Windows 64-bit GOOS=windows GOARCH=amd64 go build -o mycli-windows.exe ./path/to/package # For macOS 64-bit GOOS=darwin GOARCH=amd64 go build -o mycli-macos ./path/to/package # For Linux 64-bit GOOS=linux GOARCH=amd64 go build -o mycli-linux ./path/to/package

توزيع تطبيق CLI الخاص بك

يمكنك توزيع الملفات الثنائية القابلة للتنفيذ Go CLI من خلال توفير خيارات التنزيل المباشر على موقع الويب الخاص بمشروعك أو ضمن وثائق README. بدلاً من ذلك ، قم بالتوزيع كحزم خاصة بالمنصة باستخدام أنظمة الحزم أو المستودعات أو مديري الحزم. تتضمن بعض أنظمة إدارة الحزم الشائعة ما يلي:

• Homebrew - مدير حزم لنظامي التشغيل macOS و Linux مع بنية سهلة الاستخدام لتثبيت الحزم وإدارتها.
• APT (الأنظمة المستندة إلى Debian) - مدير حزم لتوزيعات Linux التي تستند إلى Debian مثل Ubuntu.
• RPM (الأنظمة المستندة إلى Red Hat) - مدير حزم لتوزيعات Linux التي تعتمد على Red Hat مثل Fedora.

الأفكار والموارد النهائية

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

• وثائق Go Official - دليل شامل حول لغة برمجة Go ومكتبتها القياسية.
• Go Learning Resources - قائمة شاملة من موارد Go التعليمية ، بما في ذلك البرامج التعليمية والكتب والدورات التدريبية.
• Awesome Go - قائمة منظمة من حزم Go والمكتبات والموارد ، مصنفة حسب الموضوع.
• الذهاب حسب المثال - نهج عملي لـ Go ، يعرض أمثلة وتفسيرات موجزة لمختلف ميزات Go.

علاوة على ذلك ، ضع في اعتبارك استكشاف الأنظمة الأساسية no-code مثل AppMaster.io التي تستخدم Go (golang) كلغة البرمجة الخلفية. يوفر AppMaster.io واجهة سحب وإفلات سهلة تتيح لك تطوير تطبيقات الويب والجوال والخلفية دون كتابة سطر واحد من التعليمات البرمجية. من خلال فهم كل من منصات Go و no-code مثل AppMaster.io ، ستكون مجهزًا جيدًا لتطوير حلول برمجية أكثر تعقيدًا في المستقبل.