एक नेस्टेड संरचना को प्रारंभ करें

Question

मैं यह पता नहीं लगा सकता कि एक नेस्टेड संरचना को कैसे शुरू किया जाए। एक उदाहरण यहां देखें: http://play.golang.org/p/NL6VXdHrjh

package main

type Configuration struct {
    Val   string
    Proxy struct {
        Address string
        Port    string
    }
}

func main() {

    c := &Configuration{
        Val: "test",
        Proxy: {
            Address: "addr",
            Port:    "80",
        },
    }

}

Comments

बस सीखने जाना और बिल्कुल वही सवाल था। आप सरणियों और मानचित्रों के लिए तत्व प्रकारों को छोड़ सकते हैं लेकिन नेस्टेड संरचनाओं के लिए नहीं। अवैध और असुविधाजनक। कोई समझा सकता है क्यों?

— पीटर डोटचेव

Answer 1

ठीक है, प्रॉक्सी को अपना ढांचा नहीं बनाने का कोई खास कारण?

वैसे भी आपके पास 2 विकल्प हैं:

उदाहरण के लिए, उचित तरीका, बस प्रॉक्सी को अपनी संरचना में स्थानांतरित करें:

type Configuration struct {
    Val string
    Proxy Proxy
}

type Proxy struct {
    Address string
    Port    string
}

func main() {

    c := &Configuration{
        Val: "test",
        Proxy: Proxy{
            Address: "addr",
            Port:    "port",
        },
    }
    fmt.Println(c)
    fmt.Println(c.Proxy.Address)
}

कम उचित और बदसूरत तरीका लेकिन अभी भी काम करता है:

c := &Configuration{
    Val: "test",
    Proxy: struct {
        Address string
        Port    string
    }{
        Address: "addr",
        Port:    "80",
    },
}

Comments

दूसरी विधि में, क्या हम दोहरावदार संरचनात्मक परिभाषा से बच सकते हैं?

— गौरव ओझा

@ गौरव ओझा हर तरह से नहीं, लेकिन play.golang.org/p/n24BD3NlIR

— OneOfOne

मुझे लगता है कि एक एम्बेडेड प्रकार का उपयोग करना एक संबंध के लिए अधिक उपयुक्त है।

— पटाखा

जैसा कि @sepehr द्वारा नीचे बताया गया है कि आप सीधे डॉट नोटेशन का उपयोग करके चर का उपयोग कर सकते हैं।

— स्नैसर

क्या होगा यदि प्रॉक्सी के पास एक क्षेत्र है जिसमें प्रकार है? एक और नेस्टेड संरचना के अंदर उन्हें कैसे इनिशियलाइज़ किया जाए?

— कृष्णशीतम

Answer 2

यदि आप नेस्टेड संरचना के लिए अलग संरचना परिभाषा के साथ नहीं जाना चाहते हैं और आपको @OneOfOne द्वारा सुझाई गई दूसरी विधि पसंद नहीं है तो आप इस तीसरी विधि का उपयोग कर सकते हैं:

package main
import "fmt"
type Configuration struct {
    Val   string
    Proxy struct {
        Address string
        Port    string
    }
}

func main() {
    c := &Configuration{
        Val: "test",
    }

    c.Proxy.Address = `127.0.0.1`
    c.Proxy.Port = `8080`
}

आप इसे यहाँ देख सकते हैं: https://play.golang.org/p/WoSYCxzCF2

Comments

वाह, नेस्टेड स्ट्रक्चर को इनिशियलाइज़ करने के सवाल का एक वास्तविक जवाब ।

— मैक्स

यह वास्तव में बहुत अच्छा है, लेकिन अगर हम इसे एक पंक्ति में कर सकते हैं तो बेहतर होगा!

— गौरव ओझा

मैं एक ऐसे रास्ते की तलाश में था जहाँ आपको काम करने की आवश्यकता न हो, c.Proxy.Address = `127.0.0.1` c.Proxy.Port = `8080` क्या &Configuration{}असाइनमेंट के दौरान उन मूल्यों को शुरू करने का कोई तरीका है ?

— मथियस फेलिप

लेकिन फिर आप को परिभाषित करने के लिए है @MatheusFelipe आप कर सकते हैं Proxyअपने स्वयं के struct के रूप में, @OneOfOne द्वारा जवाब में पहली विधि देखें

— sepehr

IMO, यह स्वीकृत उत्तर से बेहतर है।

— डोमोइरैगेटो

Answer 3

अपनी Proxyसंरचना को अलग, Configurationइस तरह से परिभाषित करें :

type Proxy struct {
    Address string
    Port    string
}

type Configuration struct {
    Val string
    P   Proxy
}

c := &Configuration{
    Val: "test",
    P: Proxy{
        Address: "addr",
        Port:    "80",
    },
}

Http://play.golang.org/p/7PELCVsQIc देखें

Comments

अगर P Proxyएक सरणी है तो क्या होगा ?

— Ertuğrul Altınboğa

Answer 4

आपके पास यह विकल्प भी है:

type Configuration struct {
        Val string
        Proxy
}

type Proxy struct {
        Address string
        Port    string
}

func main() {
        c := &Configuration{"test", Proxy{"addr", "port"}}
        fmt.Println(c)
}

Comments

दूसरे प्रकार के इनिशियलाइज़र फ़ील्ड के

— पियरिक HYMBERT

अगर Proxyएक सरणी है तो क्या होगा ?

— Ertuğrul Altınboğa

Answer 5

जब आप किसी बाहरी पैकेज में परिभाषित सार्वजनिक प्रकार को इंस्टेंट करना चाहते हैं, तो एक गेटा उत्पन्न होता है और यह प्रकार अन्य प्रकारों को एम्बेड करता है जो निजी हैं।

उदाहरण:

package animals

type otherProps{
  Name string
  Width int
}

type Duck{
  Weight int
  otherProps
}

आप Duckअपने स्वयं के कार्यक्रम में तुरंत कैसे कर सकते हैं ? यहाँ सबसे अच्छा मैं के साथ आ सकता है:

package main

import "github.com/someone/animals"

func main(){
  var duck animals.Duck
  // Can't instantiate a duck with something.Duck{Weight: 2, Name: "Henry"} because `Name` is part of the private type `otherProps`
  duck.Weight = 2
  duck.Width = 30
  duck.Name = "Henry"
}

Comments

उन लोगों के लिए जो मेरे जैसे कैसे भूल गए, कैपिटल अक्षरों के साथ अपनी संरचनात्मक विशेषताओं का नाम दें अन्यथा, आपको cannot refer to unexported field or method त्रुटि का सामना करना पड़ेगा ।

— तेगावाद

Answer 6

आप newहाथ से सभी फ़ील्ड का उपयोग और आरंभ करना भी आवंटित कर सकते हैं

package main

type Configuration struct {
    Val   string
    Proxy struct {
        Address string
        Port    string
    }
}

func main() {
    c := new(Configuration)
    c.Val = "test"
    c.Proxy.Address = "addr"
    c.Proxy.Port = "80"
}

खेल के मैदान में देखें: https://play.golang.org/p/sFH_-HawO_M

Answer 7

आप एक संरचना को परिभाषित कर सकते हैं और दूसरी वस्तु में इसकी वस्तु बना सकते हैं जैसे मैंने नीचे किया है:

package main

import "fmt"

type Address struct {
    streetNumber int
    streetName   string
    zipCode      int
}

type Person struct {
    name    string
    age     int
    address Address
}

func main() {
    var p Person
    p.name = "Vipin"
    p.age = 30
    p.address = Address{
        streetName:   "Krishna Pura",
        streetNumber: 14,
        zipCode:      475110,
    }
    fmt.Println("Name: ", p.name)
    fmt.Println("Age: ", p.age)
    fmt.Println("StreetName: ", p.address.streetName)
    fmt.Println("StreeNumber: ", p.address.streetNumber)
}

आशा है कि यह आपकी मदद करेगा :)

Answer 8

के दौरान आपको अनाम संरचना को फिर से परिभाषित करने की आवश्यकता है &Configuration{}

package main

import "fmt"

type Configuration struct {
    Val   string
    Proxy struct {
        Address string
        Port    string
    }
}

func main() {

    c := &Configuration{
        Val: "test",
        Proxy: struct {
            Address string
            Port    string
        }{
            Address: "127.0.0.1",
            Port:    "8080",
        },
    }
    fmt.Println(c)
}

https://play.golang.org/p/Fv5QYylFGAY