`नया...` कंस्ट्रक्टर पैटर्न

गो में कोई constructor कीवर्ड नहीं है। सम्मेलन एक कारखाना है फ़ंक्शन जो उचित रूप से आरंभीकृत मान या सूचक लौटाता है। द्वारा नाम से इसे आमतौर पर NewT (या NewXxx) कहा जाता है।

आधार पैटर्न: NewT

type User struct {
    Name string
    Age  int
}

func NewUser(name string, age int) *User {
    return &User{Name: name, Age: age}
}

u := NewUser("Ada", 36)
fmt.Println(u.Name)

प्रत्यक्ष शाब्दिक &User{...} पर लाभ:

• आप सत्यापन और डिफ़ॉल्ट को केंद्रीकृत करते हैं।
• आपके पास अनएक्सपोर्टेड फ़ील्ड हो सकते हैं और उन्हें केवल कंस्ट्रक्टर से ही पॉप्युलेट किया जा सकता है।
• आप कॉलर्स को तोड़े बिना कार्यान्वयन को बदल सकते हैं।

सत्यापन के साथ कंस्ट्रक्टर: (*T, त्रुटि)

जब आरंभीकरण विफल हो सकता है, तो (*T, error) लौटाएँ:

import "errors"

func NewUser(name string, age int) (*User, error) {
    if name == "" {
        return nil, errors.New("nome obbligatorio")
    }
    if age < 0 {
        return nil, errors.New("eta non valida")
    }
    return &User{Name: name, Age: age}, nil
}

u, err := NewUser("Ada", 36)
if err != nil {
    // handle...
}

यह किसी भी कंस्ट्रक्टर के लिए मुहावरेदार पैटर्न है पूर्व शर्तें: डीबी कनेक्शन, फ़ाइल हैंडल, सर्वर कॉन्फिगरेशन, आदि।

एकाधिक निर्माणकर्ता

यदि आपके पास निर्माण के कई "तरीके" हैं, तो वर्णनात्मक नामों का उपयोग करें:

func NewUser(name string) *User { ... }
func NewUserFromJSON(data []byte) (*User, error) { ... }
func NewAdmin() *User { ... }

गो में कोई ओवरलोडिंग नहीं: नाम स्पष्ट नहीं है।

कार्यात्मक विकल्प (उन्नत झलक)

जब कई वैकल्पिक पैरामीटर होते हैं, तो मुहावरेदार पैटर्न होता है "कार्यात्मक विकल्प":

type Option func(*Server)

func WithPort(p int) Option {
    return func(s *Server) { s.Port = p }
}

func WithTLS(cert, key string) Option {
    return func(s *Server) { s.Cert, s.Key = cert, key }
}

func NewServer(opts ...Option) *Server {
    s := &Server{Port: 8080} // default
    for _, opt := range opts {
        opt(s)
    }
    return s
}

s := NewServer(WithPort(9000), WithTLS("c.pem", "k.pem"))

यह शाब्दिक से अधिक क्रियात्मक है लेकिन कई वैकल्पिक के साथ अच्छी तरह मेल खाता है पैरामीटर और पश्चवर्ती अनुकूलता को सुरक्षित रखता है (एक नया Option जोड़ना) मौजूदा कॉलर्स को नहीं तोड़ता)।

जब आपको कंस्ट्रक्टर की आवश्यकता न हो

यदि प्रकार का शून्य मान पहले से ही उपयोगी है, तो कॉल करने वाले को इसका उपयोग करने दें प्रत्यक्ष शाब्दिक. विहित उदाहरण: sync.Mutex का कोई कंस्ट्रक्टर नहीं है, var m sync.Mutex पहले से ही उपयोग के लिए तैयार म्यूटेक्स है। bytes.Buffer के लिए भी ऐसा ही।

नियम है: "शून्य मान को उपयोगी बनाएं"। यदि आप कर सकते हैं, नहीं अनिवार्य निर्माता.

इसे अजमाएं

// Which signature is more idiomatic?

संक्षिप्त

• नहीं constructor: NewT फ़ंक्शन (या उसी नाम वाले पैकेज के अंदर New) का उपयोग करें।
• साधारण मामले के लिए *T लौटाएँ; (*T, error) पूर्व शर्तों या सत्यापन के साथ।
• त्रुटि होने पर: सूचक के रूप में nil और दूसरे मान के रूप में व्याख्यात्मक त्रुटि लौटाएँ।
• कोई ओवरलोडिंग नहीं; वर्णनात्मक नामों का उपयोग करें (NewUserFromJSON, NewAdmin)।
• "शून्य मान को उपयोगी बनाएं": यदि आप कर सकते हैं, तो कंस्ट्रक्टर अनावश्यक है।
• कई वैकल्पिक मापदंडों के लिए उन्नत पैटर्न: कार्यात्मक विकल्प।