golang給函數(shù)參數(shù)設置默認值的幾種方式小結(函數(shù)參數(shù)默認值

更新時間：2023年01月06日 13:14:22 作者：學亮編程手記

在日常開發(fā)中我們有時候需要使用默認設置,下面這篇文章主要給大家介紹了關于golang給函數(shù)參數(shù)設置默認值的幾種方式小結的相關資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下

前言

這個問題相當麻煩，根據(jù)golang-nuts/google groups中的這篇文章，golang現(xiàn)在與將來都不會支持參數(shù)默認值。Go始終在使得自己變得盡可能的簡單，而增加這種額外的支持會使parser變得更復雜。

設置參數(shù)值的好處：

可以缺省部分參數(shù)。
可以提供一種默認的，行之有效的配置。

但是參考資料中提到了幾種實現(xiàn)默認值的方法：

強制改變

// Both parameters are optional, use empty string for default value
func Concat1(a string, b int) string {
  if a == "" {
    a = "default-a"
  }
  if b == 0 {
    b = 5
  }
 
  return fmt.Sprintf("%s%d", a, b)
}

go的一大特點就是所有的變量都必須經過初始化。那如果在函數(shù)內部讀取到參數(shù)值為初始化值，即可進行對應的操作。但是這種方法無法解決設置參數(shù)默認值時所經常應對的場景，即參數(shù)缺省問題。

使用可變參數(shù)語法糖

// a is required, b is optional.
// Only the first value in b_optional will be used.
func Concat2(a string, b_optional ...int) string {
  b := 5
  if len(b_optional) > 0 {
    b = b_optional[0]
  }
 
  return fmt.Sprintf("%s%d", a, b)
}

上述方法中，a是必須的，而b是可選的。此時b的默認值時5，如果b_optional中存在數(shù)據(jù)，則將其讀取。

利用結構體的config

// A declarative default value syntax
// Empty values will be replaced with defaults
type Parameters struct {
  A string `default:"default-a"` // this only works with strings
  B string // default is 5
}
 
func Concat3(prm Parameters) string {
  typ := reflect.TypeOf(prm)
 
  if prm.A == "" {
    f, _ := typ.FieldByName("A")
    prm.A = f.Tag.Get("default")
  }
 
  if prm.B == 0 {
    prm.B = 5
  }
 
  return fmt.Sprintf("%s%d", prm.A, prm.B)
}

雖然也能做到缺省參數(shù)（如果不設置A屬性，則該屬性將被默認初始化），但是這種方式只對字符串管用。

轉換函數(shù)的全部參數(shù)

func Concat4(args ...interface{}) string {
  a := "default-a"
  b := 5
 
  for _, arg := range args {
    switch t := arg.(type) {
      case string:
        a = t
      case int:
        b = t
      default:
        panic("Unknown argument")
    }
  }
 
  return fmt.Sprintf("%s%d", a, b)
}

相當泛用的方法，但是對于不同的類型就不可行了。

補充知識:Golang中設置函數(shù)默認參數(shù)的優(yōu)雅實現(xiàn)

在Golang中，我們經常碰到要設置一個函數(shù)的默認值，或者說我定義了參數(shù)值，但是又不想傳遞值，這個在python或php一類的語言中很好實現(xiàn)，但Golang中好像這種方法又不行。今天在看Grpc源碼時，發(fā)現(xiàn)了一個方法可以很優(yōu)雅的實現(xiàn)，叫做 Functional Options Patter.通過定義函數(shù)的方式來實現(xiàn)

比如我們以如下的構造函數(shù)為例說明下，用這個的好處

func NewClient(address string,timeout,trynums int){}

如果我們要實例化這個函數(shù),timeout,trynums這個是必須要傳的，那如果我不想傳呢，一般可能是通過傳對象(struct，map)或定義多個func，感覺都不太方便。

func NewClient(address string){}
func NewClientNoTimeout(address string,trynums int){}

另一種傳一個對象

type Options struct{
    timeout int,
    trynums int
}
func NewClient(address string,opts Options){}

用對象的形式，還得檢查參數(shù)的合法性。比如傳遞了不存在的參數(shù)等。

那么，我們看下用Functional Options Patter的方式，我寫了一個簡單的例子。

package main
 
import "fmt"
 
//如何向func傳遞默認值
 
type dialOption struct {
    Username string
    Password string
    Service  string
}
 
type DialOption interface {
    apply(*dialOption)
}
 
 
type funcOption struct {
    f func(*dialOption)
}
 
func(fdo *funcOption) apply(do *dialOption){
     fdo.f(do)
}
 
 
func newFuncOption(f func(*dialOption))*funcOption{
    return &funcOption{
        f:f,
    }
}
 
func withUserName(s string) DialOption{
    return  newFuncOption(func(o *dialOption){
        o.Username = s
    })
}
 
func withPasswordd(s string) DialOption{
    return  newFuncOption(func(o *dialOption){
        o.Password = s
    })
}
 
func withService(s string) DialOption{
    return  newFuncOption(func(o *dialOption){
        o.Service = s
    })
}
 
//默認參數(shù)
func defaultOptions() dialOption{
    return dialOption{
        Service:"test",
    }
}
 
type clientConn struct {
    timeout int
    dopts dialOption
}
 
 
func NewClient(address string, opts ...DialOption){
    cc :=&clientConn{
        timeout:30,
        dopts:defaultOptions(),
    }
    //循環(huán)調用opts
    for _,opt := range opts {
        opt.apply(&cc.dopts)
    }
 
    fmt.Printf("%+v",cc.dopts)
}
 
 
func main(){
    NewClient("127.0.0.1",withPasswordd("654321"),withService("habox"))
    NewClient("127.0.0.1",withService("habox"))
}

實例化時，通過func的方式來傳遞參數(shù)，也可以定義一些默認參數(shù)。如果以后要加，只需要更改很少的代碼。

而且，這種方式也不會傳遞不相關的參數(shù)，因為參數(shù)都在通過func的方式來修改的。

唯一不好的地方可能是代碼量相應的增加了。但是為了更優(yōu)雅，這種做法還是值得的。