选项模式

    1. package main
    3. import "fmt"
    5. type Options struct {
    6.     StrOption1 string
    7.     StrOption2 string
    8.     StrOption3 string
    9.     IntOption1 int
    10.     IntOption2 int
    11.     IntOption3 int
    12. }
    14. func InitOptions1(strOption1 string, strOption2 string, strOption3 string,
    15.     IntOption1 int, IntOption2 int, IntOption3 int) {
    16.     options := &Options{}
    17.     options.StrOption1 = strOption1
    18.     options.StrOption2 = strOption2
    19.     options.StrOption3 = strOption3
    20.     options.IntOption1 = IntOption1
    21.     options.IntOption2 = IntOption2
    22.     options.IntOption3 = IntOption3
    24.     fmt.Printf("init options1:%#v\n", options)
    25.     return
    26. }
    28. func InitOptions2(opts ...interface{}) {
    29.     options := &Options{}
    30.     for index, opt := range opts {
    31.         switch index {
    32.         case 0:
    33.             str, ok := opt.(string)
    34.             if !ok {
    35.                 return
    36.             }
    37.             options.StrOption1 = str
    38.         case 1:
    39.             str, ok := opt.(string)
    40.             if !ok {
    41.                 return
    42.             }
    43.             options.StrOption2 = str
    44.         case 2:
    45.             str, ok := opt.(string)
    46.             if !ok {
    47.                 return
    48.             }
    49.             options.StrOption3 = str
    50.         case 3:
    51.             val, ok := opt.(int)
    52.             if !ok {
    53.                 return
    54.             }
    55.             options.IntOption1 = val
    56.         case 4:
    57.             val, ok := opt.(int)
    58.             if !ok {
    59.                 return
    60.             }
    61.             options.IntOption2 = val
    62.         case 5:
    63.             val, ok := opt.(int)
    64.             if !ok {
    65.                 return
    66.             }
    67.             options.IntOption3 = val
    68.         }
    69.     }
    70.     fmt.Printf("init options2:%#v\n", options)
    71. }
    73. type Option func(opts *Options)
    75. func InitOption3(opts ...Option) {
    76.     options := &Options{}
    77.     for _, opt := range opts {
    78.         opt(options)
    79.     }
    81.     fmt.Printf("init options3:%#v\n", options)
    82. }
    84. func WithStringOption1(str string) Option {
    85.     return func(opts *Options) {
    86.         opts.StrOption1 = str
    87.     }
    88. }
    90. func WithStringOption2(str string) Option {
    91.     return func(opts *Options) {
    92.         opts.StrOption2 = str
    93.     }
    94. }
    96. func WithStringOption3(str string) Option {
    97.     return func(opts *Options) {
    98.         opts.StrOption3 = str
    99.     }
    100. }
    102. func WithIntOption1(val int) Option {
    103.     return func(opts *Options) {
    104.         opts.IntOption1 = val
    105.     }
    106. }
    108. func WithIntOption2(val int) Option {
    109.     return func(opts *Options) {
    110.         opts.IntOption2 = val
    111.     }
    112. }
    114. func WithIntOption3(val int) Option {
    115.     return func(opts *Options) {
    116.         opts.IntOption3 = val
    117.     }
    118. }
    120. func main() {
    121.     InitOptions1("str1", "str2", "str3", 1, 2, 3)
    122.     InitOptions2("str1", "str2", "str3", 1, 2, 3)
    123.     InitOption3(
    124.         WithStringOption1("str1"),
    125.         WithStringOption3("str3"),
    126.         WithIntOption3(3),
    127.         WithIntOption2(2),
    128.         WithIntOption1(1),
    129.         WithStringOption2("str2"),
    130.     )
    131. }