JAPANESE
https://neovisionconsulting.blogspot.com/2022/05/vwasmvvgographqlaiwebwebtool20220504.html
ー－－
https://neovisionconsulting.blogspot.com/2022/05/in-future-v-wasm-v-frameworks-etc-would.html
ー－－
زبان WASM V
یادداشت (طبقه / ارث) که من به زبان Go معتاد بودم
گلنگ را شروع کردم.
همانطور که در ابتدا احساس کردم، Golang طوری طراحی شده است که دستور زبان را تا حد امکان ساده و کد را تا حد امکان ساده نگه دارد.
و برای آن، Golang دارای نحو پیچیده ای است.
با این حال، بدون اینکه آنها را بشناسم، اغلب به قضاوت بر اساس پیش فرض ها و باورهای خودخواهانه به زبان های دیگر معتاد بودم.
در اینجا، زمانی که گلنگ را شروع کردم، می خواهم یادداشتی از اعتیادها و سوء تفاهمات شخصی بر اساس موضوع تهیه کنم.
این بار یادداشتی در مورد طبقات و ارث در گلنگ است.
گولنگ کلاس ندارد
گفته می شود گولنگ کلاس ندارد، اما این درست است.
با این حال، چیزی نزدیک به کلاس وجود دارد.
در وهله اول، کارهای اصلی که می خواهم در کلاس انجام دهم به شرح زیر است.
- ترکیب چندین متغیر در یک گروه (متغیرهای عضو)
- توابعی را تعریف کنید که می توانند با پیوند دادن آنها به یکدیگر عمل کنند (عضو تابع)
در Golang از "ساختار" برای ترکیب چندین متغیر در یک گروه استفاده می شود و تابعی که گروه را عمل می کند می تواند یک تابع خاص مرتبط با ساختار را تعریف کند. من متوجه شدم.
به عنوان مثال، یک کلاس کلاس مانند با متغیرهای عضو "x" و "y" و یک تابع عضو "test ()" برای بدست آوردن مقدار کل آنها را می توان به صورت زیر ایجاد کرد.
بسته اصلی
وارد کردن "fmt"
// متغیرها را در یک ساختار
نوع myStruct struct {
x int
y int
}
// تابعی که ساختار
تابع را دستکاری می کند (p * myStruct) test () int {
بازگشت px + py توسط عملگر ساختار "." فراخوانی شده است.
}
func main () {
var a myStruct
ax = 1
ay = 2
fmt.Println (a.test ()) // 3
}
تابع "test ()" کمی ناآشنا است، اما .یک تابع عضو است که از عملگر "" در ساختار فراخوانی می شود.
از آنجایی که هر کسی از بیرون می تواند به عناصر یک ساختار دسترسی داشته باشد، می توان با در نظر گرفتن یک ساختار به عنوان آرگومان و نوشتن تابعی که بدون تعریف تابع عضو روی ساختار عمل می کند، به همین موضوع دست یافت.
بسته اصلی
وارد کردن "fmt"
myStruct struct { _
x int
y int
}
// یک ساختار را به عنوان آرگومان بگیرید و تست تابع ساختار (p * myStruct) int {
return px + py را اجرا کنید
}
func main () {
var a myStruct
ax = 1
ay = 2
fmt.Println (تست (و a)) // 3
}
با این حال، حتی در یک ساختار، روش خاصی برای نوشتن یک تابع وجود دارد که می توان آن را .با عملگر "" فراخوانی کرد، همانطور که می توانید آن توابع عملیاتی را با عملگر "" مانند یک کلاس بنویسید..
اگر آن را به این صورت بنویسید، در نگاه اول مانند یک تابع عضو یک کلاس به نظر می رسد.
در واقع، من یک تابع را با ارسال یک ساختار (یا یک اشاره گر به ساختار) دستکاری می کنم، اما این یک کلاس در Golang است که نوشتن مانند یک تابع عضو یک ساختار را ممکن می کند.
وراثت
همانطور که در بالا ذکر شد، هیچ کلاسی در Golang وجود ندارد، آن "struct + ساختار تابع عملیات = کلاس مانند" است.
مواقعی وجود دارد که می خواهید کلاسی را که قبلاً با اضافه کردن متغیرها و توابع دستکاری بعداً تعریف شده است گسترش دهید. به اصطلاح وراثت طبقاتی است.
Golang می تواند آن ارث را نیز انجام دهد.
اگر ساختار والد را به عنوان عنصری از ساختار فرزند فقط با نام ساختار والد بدون نام عنصر ثبت کنید، می توانید با نام عنصر نام ساختار والد به ساختار والد دسترسی پیدا کنید.
اگر آن را در جملات بنویسید، درک آن دشوار است، بنابراین اگر آن را با کد بنویسید، مانند زیر خواهد بود.
بسته اصلی
وارد کردن "fmt"
//
نوع ساختار والد ساختار parentStruct {
x int
y int
}
// تابع ساختار والد
تابع (p * parentStruct) testParent () {
fmt.Println ( «والد» ، px، py)
}
//
نوع ساختار کودک ساختار childStruct {
z int
parentStruct // ساختار والد
}
// تابع ساختار فرزند
( p * childStruct) testChild () {
// دسترسی به متغیر ساختار والد
fmt.Println ( "فرزند" , 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 () // Child 1 2 3 به تابع فرزند دسترسی پیدا کنید
}
وراثت
با نگاهی به کد بالا، طبیعی به نظر می رسد که ساختار فرزند به جای ارث بری ساختار والد، تنها دارای عناصر ساختار والد است.
با این حال، کلید اینجاست.
اگر ساختار فوق را بنویسید، می توانید متغیرهای عضو / توابع ساختار والد را با نوشتن متغیرها / توابع عضو مستقیماً زیر ساختار فرزند فراخوانی کنید.
به عبارت دیگر، کد بالا را می توان به صورت زیر با حذف نام ساختار والد نیز نوشت.
بسته اصلی
وارد کردن "fmt"
//
نوع ساختار والد ساختار parentStruct {
x int
y int
}
// تابع ساختار والد
تابع (p * parentStruct) testParent () {
fmt.Println ( «والد» ، px، py)
}
//
نوع ساختار کودک ساختار childStruct {
z int
parentStruct
}
// تابع ساختار فرزند
( p * childStruct) testChild () {
// دسترسی به متغیر ساختار والد
fmt.Println ( "فرزند" , px, py, pz) // می توانید تغییر ساختار والد را حذف کنید.
}
func main () {
var a childStruct
ax = 1 // دسترسی به متغیر والد
ay = 2 // دسترسی به ساختار والد می توانید اصلاح ساختار والد را حذف کنید
az = 3
a.testParent () // Parent 1 2 Parent می توانید اصلاح ساختار والد را حذف کنید
a.testChild () // Child 1 2 3
}
اگر بتوانید آن را اینگونه بنویسید، در یک نگاه مانند ارث به نظر می رسد.
در واقع، فقط به این دلیل که یک ساختار والد در عناصر خود دارد، ارث نیست، بلکه وراثت در Golang است که به شما امکان می‌دهد آن را به‌عنوان ارثی بنویسید.
اگر نام عناصر و توابع پوشش داده شود چه؟
اگر عنصر یا تابعی را در ساختار فرزند تعریف کنید که نامی مشابه با ساختار والد داشته باشد، چه؟
در آن صورت از عناصر / توابع ساختار فرزند استفاده می شود. از آنجایی که چاره ای جز دسترسی به عناصر و توابع ساختار والد وجود ندارد، نام ساختار والد را همانطور که در ابتدا توضیح داده شد، مشخص کنید.
بسته اصلی
وارد کردن "fmt"
ساختار parentStruct { _
x int
y int
}
تست func (p * parentStruct) () {
fmt.Println ( «والد» ، px، py)
}
ساختار childStruct را تایپ کنید {
x int
parentStruct
}
تست func (p * childStruct) () {
// از آنجایی که x تکراری است، برای دسترسی به x از ساختار والد، ساختار والد
fmt.Println را مشخص کنید ( "Child" , p.parentStruct.x, py , px)
}
func main ( ) {
var
a childStruct
//
x تکراری است، بنابراین برای دسترسی به
x در ساختار والد، ساختار والد را مشخص کنید . دسترسی به تست ساختار والد ()، ساختار والد را مشخص کنید
a.parentStruct.test () // Parent 1 2
a.test () // Child 1 2 3
}
به عبارت دیگر، "شما می توانید یک متغیر عضو / تابع یک ساختار والد را با نوشتن یک متغیر / تابع عضو مستقیماً زیر ساختار فرزند فراخوانی کنید" به این معنی است که کامپایلر می تواند به کد نگاه کند و نام ساختار والد را در پشت صحنه تکمیل کند. آنها آن را انجام می دهند.
استفاده از ارث
مواقعی وجود دارد که می خواهید عناصر یا توابعی را به ساختاری که قبلاً به عنوان یک شی ایجاد شده است اضافه کنید. در چنین مواقعی با استفاده از ارث می توانید احساس خوبی به آن بدهید.
به عنوان مثال، فرض کنید می خواهید ساختار http.Clinet را برای انجام جستجوی گوگل و حفظ نتایج گسترش دهید.
بسته اصلی
import (
"fmt"
"io / ioutil"
"net / http"
)
// ساختار googleSearch را تایپ کنید که ساختاری با عملکرد جدید را به ارث می برد {رشته
نتیجه // Result
* http.Client // اشاره گر به ساختار ارثی
}
// تابع افزودن جستجو () ذخیره نتایج جستجو در نتیجه
تابع (p * googleSearch) جستجو (q string ) {
resp, err: = p.Get (fmt.Sprintf ( "https://www.google.com?q=%s" , q))
اگر er! = nil {
return
}
به تعویق انداختن پاسخ بدن. بستن ()
body, err: = ioutil.ReadAll (resp.Body)
اگر اشتباه کرد! = صفر {
بازگشت
}
p.result = رشته (بدنه)
}
تابع اصلی () {
c: = & http.Client {}
g: = googleSearch {Client: c} // http.Client را به ارث برده و عناصر / توابع جدید را اضافه کنید
g.search ( "test" )
fmt.Println (g.result)
}
موارد زیادی وجود دارد که یک ساختار با اشاره گر به دست می آید و در چنین مواردی، نکته دریافت ساختار والد با اشاره گر است.
هنگام ایجاد یک ساختار توسعه یافته، نشانگر به دست آمده را به نشانگر ساختار والد اختصاص دهید.
سپس، می توانید به عناصر / توابع ساختار والد مستقیماً از ساختار فرزند دسترسی داشته باشید.
برداشت ها و غیره
از آنجایی که تعریف سازه و عملکرد عملیاتی آن در مکان های مختلف مستقل است، یافتن اینکه سازه در مقایسه با کلاس دارای چه نوع عملکرد عملیاتی است دشوار است.
در واقع، ساختارها ساختار هستند، توابع مستقل از توابع هستند، و کامپایلر فقط آنها را در کدنویسی پیوند می دهد، و ساختارها همیشه درگیر توابع عضوشان هستند.
دستور زبان گولنگ ابتدایی است، اما می توان آن را به روش های مختلف نوشت و حذف کرد، به طوری که می توان آن را به همان شیوه یک زبان با کارایی بالا نوشت.
هوم گولنگ زبانی منطقی و کاملاً جالب است.
0 コメント:
コメントを投稿