ஒரு கட்டமைப்பை வரையறுத்தல் மற்றும் பயன்படுத்துதல்

ஒரு struct குழுக்கள் பெயரிடப்பட்ட புலங்கள் ஒரு வகை. இது கோவின் வழி "பொருட்களை" உருவாக்குவது - வகுப்புகளை விட நேரடியான மற்றும் உடனடி பரம்பரை இல்லை மற்றும் உள்ளமைக்கப்பட்ட கட்டமைப்பாளர்கள் இல்லை.

பிரகடனம்

type Person struct {
    Name string
    Age  int
}

type ஒரு புதிய பெயரிடப்பட்ட வகையை அறிமுகப்படுத்துகிறது. புலங்கள் ஒன்றுக்கு ஒன்று எழுதப்பட்டுள்ளன வரி, name type. ஒரே வகையின் தொடர்ச்சியான புலங்கள் பகிரலாம் பிரகடனம்: X, Y int.

உருவாக்கம்

// with named fields (recommended: robust to reordering)
p := Person{Name: "Ada", Age: 36}

// positional (fragile: depends on declaration order)
q := Person{"Ada", 36}

// zero value: every field at its zero value
var r Person          // r = {Name: "", Age: 0}

// pointer: allocate with & or new
ptr := &Person{Name: "Ada"}
ptr2 := new(Person)   // *Person to a zero-value struct

கள அணுகல்

p := Person{Name: "Ada", Age: 36}
fmt.Println(p.Name, p.Age)

p.Age = 37            // mutation (if p is a variable)

ஒரு சுட்டியில், ptr.Name நேரடியாக வேலை செய்கிறது: Go அதைச் செய்கிறது ** மறைமுகமான மரியாதை**. C இல் உள்ளதைப் போல -> இல்லை.

தெரிவுநிலை: பெரிய எழுத்து விதி

பெரிய எழுத்துக்கள் உள்ள புலங்கள் ஏற்றுமதி செய்யப்படுகின்றன (மற்றவற்றிலிருந்து தெரியும் தொகுப்புகள்); சிறிய எழுத்து = தற்போதைய தொகுப்புக்கு தனிப்பட்டது.

type User struct {
    Name   string  // exported
    salt   []byte  // private to the package
}

Go: வகைகளில் உள்ள ஒவ்வொரு அடையாளங்காட்டிக்கும் இதே விதி பொருந்தும். செயல்பாடுகள், மாறிகள், புலங்கள்.

அநாமதேய மற்றும் உள்ளமைக்கப்பட்ட கட்டமைப்புகள்

// anonymous (handy for ad-hoc data)
config := struct {
    Host string
    Port int
}{Host: "localhost", Port: 8080}

// nested
type Address struct {
    Street string
    City   string
}
type Customer struct {
    Name    string
    Address Address
}

ஒப்பீடு

இரண்டு கட்டமைப்புகள் == உடன் ஒப்பிடத்தக்கவை என்றால் அவற்றின் எல்லாப் புலங்களும் ஒப்பிடத்தக்கது (உள்ளே துண்டுகள்/வரைபடங்கள்/பங்குகள் இல்லை):

a := Person{Name: "Ada", Age: 36}
b := Person{Name: "Ada", Age: 36}
fmt.Println(a == b)   // true

இது வரைபட விசைகளாக பயன்படுத்தவும் உங்களை அனுமதிக்கிறது.

முயற்சி செய்து பாருங்கள்

// in package other
type X struct {
    name string
}

மறுபரிசீலனை

• type Name struct { ... }: பெயரிடப்பட்ட புலங்களுடன் புதிய பெயரிடப்பட்ட வகை.
• கட்டுமானம்: T{Field: value, ...} (பரிந்துரைக்கப்பட்டது) அல்லது நிலை.
• பூஜ்ஜிய மதிப்பு: ஒவ்வொரு புலமும் அதன் வகையின் பூஜ்ஜியத்தில்.
• ஒரு சுட்டிக்கு &T{...} மற்றும் new(T); மறைமுகமான மரியாதை (p.Field இல் *T).
• பெரிய எழுத்து = ஏற்றுமதி செய்யப்பட்டது; சிறிய எழுத்து = தொகுப்பிற்கு தனிப்பட்டது.
• அனைத்து புலங்களும் இருந்தால் == உடன் ஒப்பிடக்கூடியது; வரைபட விசைகளாகப் பயன்படுத்தலாம்.