Constructors in Go

by

There are some equivalents of constructors for when the zero values can’t make sensible default values or for when some parameter is necessary for the struct initialization.

Supposing you have a struct like this :

type Thing struct {
    Name  string
    Num   int
}

then, if the zero values aren’t fitting, you would typically construct an instance with a NewThing function returning a pointer :

func NewThing(someParameter string) *Thing {
    p := new(Thing)
    p.Name = someParameter
    p.Num = 33 // <- a very sensible default value
    return p
}

When your struct is simple enough, you can use this condensed construct :

func NewThing(someParameter string) *Thing {
    return &Thing{someParameter, 33}
}

If you don’t want to return a pointer, then a practice is to call the function makeThing instead of NewThing :

func makeThing(name string) Thing {
    return Thing{name, 33}
}

Reference : Allocation with new in Effective Go.

More Related Contents:

  1. is it possible to call overridden method from parent struct in Golang?
  2. How much work should be done in a constructor?
  3. What is an example of the Liskov Substitution Principle?
  4. What’s wrong with overridable method calls in constructors?
  5. What is polymorphism, what is it for, and how is it used?
  6. Difference between abstraction and encapsulation?
  7. Monad in plain English? (For the OOP programmer with no FP background)
  8. What is the exact problem with multiple inheritance?
  9. Why can’t I seem to grasp interfaces?
  10. Is it possible to access struct fields from within a trait?
  11. HAS-A, IS-A terminology in object oriented language
  12. Functional programming vs Object Oriented programming [closed]
  13. Explanation of the UML arrows
  14. Where do I use delegates? [closed]
  15. Difference Between Cohesion and Coupling
  16. Polymorphism – Define In Just Two Sentences [closed]
  17. Why “private” methods in the object oriented?
  18. What is the meaning and reasoning behind the Open/Closed Principle?
  19. How do I get a PHP class constructor to call its parent’s parent’s constructor?
  20. If-less programming (basically without conditionals) [closed]
  21. Are there any rules for OOP?
  22. What is the real difference between “Bastard Injection” and “Poor Man’s Injection”
  23. When to implement an interface and when to extend a superclass?
  24. Difference between value parameter and reference parameter?
  25. Differences between Proxy and Decorator Pattern
  26. What is immutability and why should I worry about it?
  27. What does ‘low in coupling and high in cohesion’ mean
  28. adapter-Any real example of Adapter Pattern [closed]
  29. Why does PHP allow “incompatible” constructors?
  30. Why should I prefer to use member initializer lists?

Leave a Comment