JAPANESE
https://neovisionconsulting.blogspot.com/2022/05/vwasmvvgographqlaiwebwebtool20220504.html
ー－－－－－－－－－－－
ENGLISH
https://neovisionconsulting.blogspot.com/2022/05/in-future-v-wasm-v-frameworks-etc-would.html
ARABIC
لغة WASM V.
مذكرة (فئة / وراثة) كنت مدمنًا عليها في لغة Go
لقد بدأت جولانج.
كما شعرت في البداية ، تم تصميم Golang لإبقاء القواعد بسيطة قدر الإمكان والرمز بسيط قدر الإمكان.
ومن أجل ذلك ، لدى Golang بعض القواعد اللغوية الصعبة.
ومع ذلك ، دون معرفتهم ، كنت غالبًا مدمنًا على إصدار أحكام بناءً على أفكار مسبقة ومعتقدات أنانية بلغات أخرى.
هنا ، عندما بدأت شركة Golang ، أود تقديم مذكرة عن الإدمان الشخصي وسوء الفهم حسب الموضوع.
هذه المرة ، إنها مذكرة حول الطبقات والميراث في جولانج.
لا توجد فصول في Golang
يقال أن جولانج ليس لديها فصول دراسية ، لكن هذا صحيح.
ومع ذلك ، هناك شيء قريب من الفصل.
في المقام الأول ، الأشياء الرئيسية التي أريد القيام بها في الفصل هي كما يلي.
- الجمع بين عدة متغيرات في مجموعة واحدة (متغيرات الأعضاء)
- تحديد الوظائف التي يمكن تشغيلها من خلال ربطها ببعضها البعض (وظيفة العضو)
في Golang ، تُستخدم "البنية" لدمج متغيرات متعددة في مجموعة واحدة ، ويمكن للوظيفة التي تشغل المجموعة تحديد وظيفة خاصة مرتبطة بالبنية. لقد أدركت ذلك.
على سبيل المثال ، يمكن إنشاء فئة تشبه فئة مع متغيري الأعضاء "x" و "y" ووظيفة العضو "test ()" للحصول على القيمة الإجمالية لها على النحو التالي.
الحزمة الرئيسية
استيراد "fmt"
// تجميع المتغيرات في هيكل
نوع myStruct Structure {
x int
y int
}
// الوظيفة التي تتلاعب في البنية
func (p * myStruct) test () int {
return px + py التي يطلق عليها "." عامل تشغيل الهيكل
}
func main () {
var a myStruct
الفأس = 1
ay = 2
fmt.Println (a.test ()) // 3
}
الوظيفة "test ()" غير مألوفة بعض الشيء ، لكنها .وظيفة عضو يتم استدعاؤها من عامل التشغيل "" في الهيكل.
نظرًا لأنه يمكن الوصول إلى عناصر الهيكل من قبل أي شخص من الخارج ، يمكن تحقيق الشيء نفسه من خلال اتخاذ بنية كحجة وكتابة وظيفة تعمل على الهيكل دون تحديد وظيفة العضو. ..
الحزمة الرئيسية
استيراد "fmt"
اكتب هيكل myStruct {
x int
y int
}
// خذ بنية كوسيطة وقم بتشغيل اختبار
func للهيكل (p * myStruct) int {
return px + py
}
func main () {
var a myStruct
الفأس = 1
ay = 2
fmt.Println (اختبار (& أ)) // 3
}
ومع ذلك ، حتى في البنية ، هناك طريقة خاصة لكتابة دالة يمكن استدعاؤها .بواسطة عامل التشغيل "" ، تمامًا كما يمكنك كتابة وظائف العملية هذه باستخدام عامل التشغيل "" مثل فئة..
إذا قمت بكتابتها على هذا النحو ، فإنها تبدو للوهلة الأولى وكأنها وظيفة عضو في فصل دراسي.
في الواقع ، أنا أتعامل مع دالة عن طريق تمرير بنية (أو مؤشر إلى الهيكل) ، لكنها فئة في Golang تجعل من الممكن الكتابة مثل وظيفة عضو في بنية.
ميراث
كما ذكرنا سابقًا ، لا توجد فئة في Golang ، إنها "وظيفة تشغيل هيكل + هيكل = فئة تشبه".
هناك أوقات تريد فيها توسيع فئة تم تعريفها بالفعل عن طريق إضافة متغيرات ووظائف معالجة لاحقًا. إنه ما يسمى بالميراث الطبقي.
يمكن لـ Golang القيام بهذه الميراث أيضًا.
إذا قمت بتسجيل بنية أصل كعنصر من بنية فرعية مع اسم الهيكل الأصلي فقط بدون اسم العنصر ، يمكنك الوصول إلى البنية الأصلية باستخدام اسم العنصر الخاص باسم البنية الأصل.
من الصعب فهم ما إذا كنت تكتبه في جمل ، لذلك إذا قمت بكتابته في رمز ، فسيبدو كما يلي.
الحزمة الرئيسية
استيراد "fmt"
//
نوع البنية الأصل رئيسي
x int
y int
}
// دالة بنية الأصل
func (p * parentStruct) testParent () {
fmt.Println ( "الأصل" ، px، py)
}
//
نوع البنية الفرعية childStruct structure {
z int
parentStruct // الهيكل الأصل
}
// func وظيفة البنية الفرعية (p * childStruct) testChild () {
// متغير الوصول إلى البنية الرئيسية
fmt.Println ( "Child" ، p.parentStruct.x، p.parentStruct.y، pz)
}
func main () {
var a childStruct
a.parentStruct.x = 1 // الوصول إلى المتغير الأصل
a.parentStruct.y = 2 // الوصول إلى المتغير الأصل
az = 3 // الوصول إلى المتغير
الفرعي a.parentStruct.testParent () // Parent 1 2 الوصول إلى الوظيفة الأصل
a.testChild () // الطفل 1 2 3 الوصول إلى وظيفة الطفل
}
ميراث
بالنظر إلى الكود أعلاه ، يبدو من الطبيعي أن بنية الطفل تحتوي فقط على عناصر البنية الأصلية بدلاً من وراثة الهيكل الأصلي.
ومع ذلك ، هنا هو المفتاح.
إذا قمت بكتابة الهيكل أعلاه ، فيمكنك استدعاء متغيرات / وظائف الأعضاء الخاصة بالبنية الأم عن طريق كتابة متغيرات / وظائف العضو مباشرة تحت الهيكل الفرعي.
بمعنى آخر ، يمكن أيضًا كتابة الكود أعلاه على النحو التالي ، مع حذف اسم الهيكل الأصلي.
الحزمة الرئيسية
استيراد "fmt"
//
نوع البنية الأصل رئيسي
x int
y int
}
// دالة بنية الأصل
func (p * parentStruct) testParent () {
fmt.Println ( "الأصل" ، px، py)
}
//
نوع البنية الفرعية childStruct structure {
z int
الوالد
}
// وظيفة الهيكل الفرعي
func (p * childStruct) testChild () {
// الوصول إلى متغير البنية الأم
fmt.Println ( "Child" ، px، py، pz) // يمكنك حذف تعديل البنية الأم.
}
func main () {
var a childStruct
ax = 1 // الوصول إلى المتغير الأصل
ay = 2 // الوصول إلى البنية الأصلية يمكنك حذف تعديل البنية الأصلية
az = 3
a.testParent () // Parent 1 2 Parent يمكنك حذف تعديل البنية الأصل
a.testChild () // طفل 1 2 3
}
إذا كان بإمكانك كتابتها على هذا النحو ، فإنها تبدو وكأنها ميراث في لمحة.
في الواقع ، ليس الميراث لمجرد أنه يحتوي على بنية أصل في عناصره ، ولكن الميراث في Golang هو الذي يسمح لك بكتابته على أنه موروث.
ماذا لو تم تغطية أسماء العناصر والوظائف؟
ماذا لو قمت بتعريف عنصر أو وظيفة في بنية فرعية لها نفس اسم الهيكل الأصلي؟
في هذه الحالة ، يتم استخدام عناصر / وظائف البنية الفرعية. نظرًا لعدم وجود خيار سوى الوصول إلى عناصر ووظائف الهيكل الأصلي ، حدد اسم الهيكل الأصلي كما هو موضح في البداية.
الحزمة الرئيسية
استيراد "fmt"
اكتب بنية الأصل _
x int
y int
}
func (p * parentStruct) test () {
fmt.Println ( "الأصل" ، px، py)
}
اكتب childStruct بنية {
س كثافة العمليات
الوالد
}
func (p * childStruct) test () {
// نظرًا لتكرار x ، للوصول إلى x للبنية الرئيسية ، حدد البنية الرئيسية
fmt.Println ( "Child" ، p.parentStruct.x ، py ، px)
}
func main () يتم تكرار {
var a childStruct
// x ، لذلك للوصول إلى x في البنية الأصلية ، حدد البنية الرئيسية
a.parentStruct.x = 1
ay = 2
ax = 3
// test () مكررة ، لذلك الوصول إلى اختبار الهيكل الأصلي () ، حدد الهيكل الأصلي
a.parentStruct.test () // Parent 1 2
a.test () // الطفل 1 2 3
}
بعبارة أخرى ، "يمكنك استدعاء متغير عضو / وظيفة للبنية الأم عن طريق كتابة متغير / وظيفة عضو مباشرة تحت البنية الفرعية" تعني أنه يمكن للمجمع أن ينظر إلى الكود ويكمل اسم البنية الأصلية خلف الكواليس. يفعلون ذلك.
استعمال الميراث
هناك أوقات تريد فيها إضافة عناصر أو وظائف إلى بنية تم إنشاؤها بالفعل ككائن. يمكنك أن تجعلها تشعر بالرضا عن طريق استخدام الميراث في مثل هذه الأوقات.
على سبيل المثال ، افترض أنك تريد توسيع بنية http.Clinet لإجراء بحث في Google والاحتفاظ بالنتائج.
الحزمة الرئيسية
استيراد (
"fmt"
"io / ioutil"
"net / http"
)
// اكتب هيكل googleSearch الذي يرث بنية بوظائف جديدة {سلسلة
النتائج // النتيجة
* http.Client // المؤشر إلى الهيكل الموروث
}
// Add search () function حفظ نتائج البحث في نتيجة
func (p * googleSearch) search (q string ) {
Resp، err: = p.Get (fmt.Sprintf ( "https://www.google.com؟q=٪s" ، q))
إذا أخطأ! = لا شيء {
إرجاع
}
تأجيل الراحة. الجسم. إغلاق ()
body ، يخطئ: = ioutil.ReadAll (resp.Body)
إذا أخطأت! = لا شيء {
عودة
}
p.result = سلسلة (نص)
}
func main () {
ج: = & http.Client {}
g: = googleSearch {Client: c} // Inherit http.Client وإضافة عناصر / وظائف جديدة
g.search ( "test" )
fmt.Println (نتيجة g)
}
هناك العديد من الحالات التي يتم فيها الحصول على بنية بمؤشر ، وفي مثل هذه الحالات ، تكون النقطة هي تلقي البنية الأصلية بمؤشر.
عند إنشاء بنية ممتدة ، قم بتعيين المؤشر المكتسب إلى مؤشر الهيكل الأصلي.
بعد ذلك ، يمكنك الوصول إلى عناصر / وظائف الهيكل الأصلي مباشرة من الهيكل الفرعي.
الانطباعات وما إلى ذلك.
نظرًا لأن تعريف الهيكل ووظيفة التشغيل الخاصة به مستقل في أماكن مختلفة ، فمن الصعب معرفة نوع وظيفة التشغيل التي قارنها الهيكل بالفئة.
في الواقع ، الهياكل عبارة عن هياكل ، والوظائف مستقلة عن الوظائف ، ويقوم المترجم فقط بربطها في الترميز ، وتشارك الهياكل دائمًا في وظائف أعضائها.
قواعد Golang بدائية ، ولكن يمكن كتابتها بطرق مختلفة وحذفها ، بحيث يمكن كتابتها بنفس طريقة اللغة عالية الأداء.
أمم. غولانغ لغة منطقية ومثيرة للاهتمام.
0 コメント:
コメントを投稿