`புதிய...` கன்ஸ்ட்ரக்டர் பேட்டர்ன்

Go இல் 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...
}

இது எந்த கன்ஸ்ட்ரக்டருக்கும் இருக்கும் idiomatic pattern முன்நிபந்தனைகள்: db இணைப்பு, கோப்பு கைப்பிடி, சர்வர் கட்டமைப்பு போன்றவை.

பல கட்டமைப்பாளர்கள்

நீங்கள் கட்டமைக்க பல "வழிகள்" இருந்தால், விளக்கமான பெயர்களைப் பயன்படுத்தவும்:

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

Go இல் ஓவர்லோடிங் இல்லை: பெயர் தெளிவற்றது.

செயல்பாட்டு விருப்பங்கள் (மேம்பட்ட பார்வை)

பல விருப்ப அளவுருக்கள் இருக்கும்போது, idiomatic pattern ஆகும் "செயல்பாட்டு விருப்பங்கள்":

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).
• "பூஜ்ஜிய மதிப்பை பயனுள்ளதாக ஆக்குங்கள்": உங்களால் முடிந்தால், கட்டமைப்பாளர் தேவையற்றது.
• பல விருப்ப அளவுருக்களுக்கான மேம்பட்ட முறை: செயல்பாட்டு விருப்பங்கள்.