నిర్మాణాన్ని నిర్వచించడం మరియు ఉపయోగించడం

A 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 నేరుగా పని చేస్తుంది: గో దీన్ని నిర్వహిస్తుంది ** అవ్యక్త అవమానం**. C లో వలె -> లేదు.

దృశ్యమానత: పెద్ద అక్షరం నియమం

పెర్‌కేస్ ఇనీషియల్ ఉన్న ఫీల్డ్‌లు ఎగుమతి చేయబడతాయి (ఇతర వాటి నుండి కనిపిస్తాయి ప్యాకేజీలు); lowcase = ప్రస్తుత ప్యాకేజీకి ప్రైవేట్.

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

గోలోని ప్రతి ఐడెంటిఫైయర్‌కు ఇదే నియమం వర్తిస్తుంది: రకాలు, విధులు, వేరియబుల్స్, ఫీల్డ్‌లు.

అనామక మరియు సమూహ నిర్మాణాలు

// 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).
• అప్పర్కేస్ = ఎగుమతి చేయబడింది; lowcase = ప్యాకేజీకి ప్రైవేట్.
• అన్ని ఫీల్డ్‌లు ఉంటే స్ట్రక్ట్‌లు ==తో పోల్చవచ్చు; మ్యాప్ కీలుగా ఉపయోగించవచ్చు.