كيفية كتابة حزم الذهاب

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



المواد ، التي نُنشر ترجمتها اليوم ، هي دليل لتطوير حزم Go-go التي يمكن توصيلها بملفات أخرى.

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

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

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

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

قبل أن نتمكن من البدء في إنشاء حزمة جديدة ، نحتاج إلى الانتقال إلى مساحة عمل Go. إنه موجود على المسار المحدد بواسطة متغير GOPATH . على سبيل المثال ، اسمح لمنظمتنا أن تسمى gopherguides . في الوقت نفسه ، نحن ، كمستودع ، نستخدم GitHub . هذا يؤدي إلى حقيقة أنه ، على طول المسار المحدد بواسطة GOPATH ، لدينا بنية المجلد التالية:

 └── $GOPATH    └── src        └── github.com            └── gopherguides 

سنقوم بتسمية الحزمة التي سنقوم بتطويرها في هذا الدليل ، greet . للقيام بذلك ، قم بإنشاء دليل gopherguides دليل gopherguides . نتيجة لذلك ، سوف تتخذ بنية المجلد الموجودة النموذج التالي:

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet 

نحن الآن على استعداد لإضافة الملف الأول إلى دليل greet . عادةً ما يسمى الملف الذي يمثل نقطة إدخال الحزمة بنفس دليل الحزمة. في هذه الحالة ، يعني هذا أننا في دليل greet.go ، greet.go ملف greet.go :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet                    └── greet.go 

في هذا الملف ، يمكننا كتابة الكود الذي نريد إعادة استخدامه في مشاريعنا. في هذه الحالة ، سنقوم بإنشاء وظيفة Hello ، والتي تعرض النص Hello, World! .

افتح ملف greet.go في محرر نصوص وأضف الكود التالي إليه:

 package greet import "fmt" func Hello() {    fmt.Println("Hello, World!") } 

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

 package greet 

هذا يخبر المترجم بقبول كل شيء في الملف كجزء من حزمة greet .

بعد ذلك ، يتم استيراد الحزم اللازمة باستخدام عبارة import . في هذه الحالة ، نحتاج إلى حزمة واحدة فقط - fmt :

 import "fmt" 

وأخيراً ، نقوم بإنشاء وظيفة Hello . ستستخدم إمكانات حزمة fmt لعرض السلسلة Hello, World! :

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

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

وهي ، سنقوم بإنشاء حزمة example . للقيام بذلك ، سوف ننطلق من نفس الافتراضات التي بدأنا منها ، greet حزمة greet . أولاً ، قم بإنشاء مجلد example في مجلد gopherguides :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                    └── example 

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

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── example                    └── main.go 

افتح الملف main.go في المحرر main.go التعليمة البرمجية التالية فيه ، والذي يسمح لك باستخدام إمكانات حزمة greet :

 package main import "github.com/gopherguides/greet" func main() {    greet.Hello() } 

لقد قمنا باستيراد حزمة main.go ملف main.go ، مما يعني أنه لاستدعاء الوظيفة المعلنة في هذه الحزمة ، نحتاج إلى استخدام نقطة الترقيم. تدوين النقطة هو بنية يتم فيها وضع نقطة بين اسم الحزمة واسم المورد الخاص بهذه الحزمة التي سيتم استخدامها. على سبيل المثال ، في حزمة greet ، تلعب وظيفة Hello دور المورد. إذا كنت بحاجة إلى استدعاء هذه الوظيفة ، : greet.Hello() استخدام تدوين النقاط : greet.Hello() .

الآن يمكنك فتح المحطة وتشغيل البرنامج:

 go run main.go 

بعد القيام بذلك ، سيعرض الجهاز ما يلي:

 Hello, World! 

الآن دعنا نتحدث عن كيفية استخدام المتغيرات المعلنة في الحزم. للقيام بذلك ، أضف تعريف المتغير إلى ملف greet.go :

 package greet import "fmt" var Shark = "Sammy" func Hello() {    fmt.Println("Hello, World!") } 

افتح الملف main.go وأضف سطرًا إليه حيث يتم استخدام وظيفة fmt.Println() لعرض قيمة متغير Shark المُعلن عنها في حزمة greet.go . وهي إحضار main.go إلى النموذج التالي:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark) } 

قم بتشغيل البرنامج مرة أخرى:

 go run main.go 

الآن سوف تقوم بإخراج ما يلي:

 Hello, World! Sammy 

الآن دعونا نتحدث عن كيفية الإعلان عن أنواع في الحزم. إنشاء نوع Octopus مع حقول Name Color ، وإنشاء طريقة الكتابة. عند استدعاء هذه الطريقة ، ستُرجع المحتويات التي تمت معالجتها بشكل خاص لحقول Octopus . دعنا greet.go إلى النموذج التالي:

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func Hello() {    fmt.Println("Hello, World!") } 

الآن افتح main.go ، قم بإنشاء مثيل لهيكل النوع الجديد فيه والرجوع إلى طريقة String() :

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String()) } 

بعد إنشاء مثيل Octopus باستخدام بنية تبدو مثل oct := greet.Octopus ، يمكنك الوصول إلى أساليب وخصائص النوع من main.go الملف main.go يتيح لك هذا ، على وجه الخصوص ، استخدام الأمر oct.String() الموجود في نهاية ملف main.go دون اللجوء إلى main.go . بالإضافة إلى ذلك ، يمكننا ، على سبيل المثال ، الرجوع إلى حقل بنية Color باستخدام بنية Color . في الوقت نفسه ، كما لو كنا نسميها الطريقة ، لا نصل إلى greet .

تستخدم طريقة String من نوع Octopus وظيفة fmt.Sprintf لتشكيل الجملة وتُرجع ، باستخدام return ، والنتيجة ، السلسلة ، إلى استدعاء الأسلوب (في هذه الحالة ، يكون هذا المكان في main.go ).

قم بتشغيل البرنامج مرة أخرى:

 go run main.go 

سيتم إخراج ما يلي إلى وحدة التحكم:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange. 

الآن وقد قمنا بتجهيز Octopus بطريقة String ، لدينا آلية إخراج معلومات نوع مناسبة لإعادة الاستخدام. إذا كنت بحاجة في المستقبل إلى تغيير سلوك هذه الطريقة ، والتي يمكن استخدامها في العديد من المشاريع ، فسيكون ذلك كافيًا لتعديل الكود في greet.go .

كيان التصدير

ربما لاحظت أن كل شيء عملنا معه أثناء الوصول إلى حزمة greet له أسماء تبدأ بحرف كبير. Go ليس لديها معدّلات وصول مثل public أو private أو protected ، والتي هي في لغات أخرى. يتم التحكم في رؤية الكيانات الخاصة بالآليات الخارجية من خلال حقيقة أن تبدأ أسمائهم بالحرف الصغير أو الكبير. نتيجة لذلك ، تتوفر الأنواع والمتغيرات والوظائف التي تبدأ أسماؤها بحرف كبير خارج الحزمة الحالية. يسمى الرمز المرئي خارج الحزمة تصدير.

إذا قمت بتجهيز نوع Octopus بأسلوب جديد يسمى reset main.go ، فيمكن استدعاء هذه الطريقة من حزمة main.go ، ولكن ليس من ملف main.go ، الموجود خارج حزمة main.go . هنا نسخة محدثة من greet.go :

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

دعنا نحاول reset الاتصال من ملف main.go :

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.reset() } 

سينتج عن هذا خطأ التحويل البرمجي التالي:

 oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset) 

لتصدير طريقة reset نوع Octopus ، تحتاج إلى إعادة تسميته ، مع استبدال الحرف الأول ، بالحرف الصغير ، برأس مال R نحن نفعل هذا من خلال تحرير greet.go :

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) Reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

سيؤدي ذلك إلى حقيقة أننا سنكون قادرين على استدعاء Reset من الحزم الأخرى ودون مواجهة رسائل خطأ:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.Reset()    fmt.Println(oct.String()) } 

قم بتشغيل البرنامج:

 go run main.go 

إليك ما يصل إلى وحدة التحكم:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color . 

عن طريق استدعاء طريقة Reset ، قمنا بمسح حقول Name Color لمثيل Octopus بنا. نتيجة لذلك ، عند استدعاء String ، حيث تم عرض محتويات حقول Name Color مسبقًا ، لا يتم عرض أي شيء الآن.

النتائج

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

أعزائي القراء! ما هي البرامج التي عادة ما تكتبها على Go؟ هل تستخدم حزم الملكية فيها؟