किसी संरचना को परिभाषित करना और उसका उपयोग करना

एक 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)।
• अपरकेस = निर्यातित; लोअरकेस = पैकेज के लिए निजी।
• यदि सभी फ़ील्ड हैं तो संरचनाएं == के साथ तुलनीय हैं; मानचित्र कुंजियों के रूप में प्रयोग करने योग्य।