Unlocking Code Elegance: Embracing the Power of Function Option Pattern in Golang Development

When dealing with complex development tasks using Golang, handling a struct with numerous optional configuration items is a common scenario. This is a shared characteristic in the design of many functions, enhancing their ease of use and flexibility. However, sometimes we might encounter the improper practice of “neglecting the use of the Function Option pattern.” In this article, I will delve into the concept of the Function Option pattern, highlighting why we should employ it. I will also provide examples to illustrate the potential issues that may arise when overlooking the Function Option pattern.

Fundamental Concepts of Function Options

In the Go language, the Function Option is a technique used for designing structs that are prepared to accept numerous configuration settings. Without the Function Option, we typically return a pointer to the struct and set the optional items through functions. Here is an example without the Function Option:

type Config struct {
     A string
     B int
 }
 ​
 func NewConfig() *Config {
     return &Config{
         A: "default A",
         B: 0,
     }
 }
 ​
 func main() {
     cfg := NewConfig()
     cfg.A = "non-default A"
     cfg.B = 1
 }

Issues Arising from Neglecting the Function Option

The problem with the above code is that if the Config struct has many settings, we must set each one, even if we are only concerned with a few. Additionally, scattered configuration code may infiltrate our business logic, making the code challenging to read and maintain.

For cases where default options are used, we end up with a partially initialized struct, risking the omission of setting crucial options, leading to bugs. Another issue is that when adding new settings, we need to locate and update each instance in the code, which can be cumbersome.

Applying the Function Option Pattern

By applying the Function Option pattern, the above code can be optimized as follows:

type Config struct {
     A string
     B int
 }
 ​
 type Option func(*Config)
 ​
 func WithA(a string) Option {
     return func(c *Config) {
         c.A = a
     }
 }
 ​
 func WithB(b int) Option {
     return func(c *Config) {
         c.B = b
     }
 }
 ​
 func NewConfig(opts ...Option) *Config {
     config := &Config{
         A: "default A",
         B: 0,
     }
     for _, opt := range opts {
         opt(config)
     }
     return config
 }
 ​
 func main() {
     cfg := NewConfig(
         WithA("non-default A"),
         WithB(1),
     )
 }

Here, the WithA() and WithB() functions return functions that modify the Config, while NewConfig() accepts these functions as parameters. This approach provides the following advantages:

• Improves code readability, allowing a clear view of which options are being modified.
• Facilitates the addition of new settings without the need to search and change every instance in the code.
• Avoids partial initialization issues since NewConfig() defaults to setting all options.

Conclusion

Overlooking the Function Option pattern can lead to code confusion, increased difficulty in maintenance, and the potential introduction of errors. When designing functions or types that accept numerous settings, using the Function Option pattern is a highly recommended practice. I hope this article helps everyone better understand and utilize this pattern, resulting in more elegant and readable Go code.