函式

函式可返回多個值，還可以給返回的多個值起名字，起名字僅用於非常簡單的函式

func eval(a,b int ,op string) int {
   switch op{
   case "+":
      return a+b
   case "-":
      return a-b
   case "*":
      return a*b
   case "/":
      q,_:=div1(a,b) //呼叫下文的除法，只返回除數，餘數可以用下劃線代替
      return q
      //return a/b
   default:
      panic("unsupported operation: "+op)

   }
}
//根據可以有兩個返回值，我們可以寫eval函式為把錯誤丟擲,返回值的常用場景，用於返回error的情況
func eval1(a,b int ,op string) (int,error) {
   switch op{
   case "+":
      return a+b,nil
   case "-":
      return a-b,nil
   case "*":
      return a*b,nil
   case "/":
      q,_:=div1(a,b) //呼叫下文的除法，只返回除數，餘數可以用下劃線代替
      return q,nil
      //return a/b
   default:
         return 0,fmt.Errorf("unsupported operation : %s" ,op)
   }
}
//除數與餘數函式
func div0(a,b int) (int,int){
   return a/b,a%b
}
//如果返回值過長，建議用div0
func div1(a,b int)(q,r int){
   q=a/b
   r=a%b
   return
}

func main() {
   //fmt.Println(eval(3,4,"c"))
   if result,err:=eval1(3,4,"c"); err != nil{
      fmt.Println("error:",err)
   }else{
      fmt.Println(result)
   }
   fmt.Println(div0(13,3))
   //接收兩個返回值
   q,r:=div1(13, 3)
   println(q,r)
}
 

go語言是函數語言程式設計，函式的引數可以是函式

上述eval方法可以實現如下：

func apply(op func(int,int) int,a,b int) int{
   p:=reflect.ValueOf(op).Pointer()
    opName:=runtime.FuncForPC(p).Name()
   fmt.Println("Calling function with %s args"+"(%d,%d)",opName,a,b)
    return op(a,b)
}
func pow(a,b int) int{
   return int(math.Pow(float64(a),float64(b)))
}
func main() {
   fmt.Println(apply(pow,3,4))
   //也可以不用重寫pow函式，直接寫匿名函式,輸出結果為main.main.func1第一個main是包名，第二個main是主函式，func1是這個匿名函式
   fmt.Println(apply(func(a,b int) int{
      return int(math.Pow(float64(a),float64(b)))
   },3,4))
   fmt.Println(sumArgs(1,2,3,4,5))
}

go語言中函式引數可變,入參可以是可變引數列表，用起來像陣列一樣用
func sumArgs(values ...int) int{
   s:=0
   for i:=range values{
      s+=values[i]

   }
   return s
}
func main() {
   fmt.Println(sumArgs(1,2,3,4,5))
}
 

函式語法要點：

• 返回值型別寫在最後面
• 可返回多個值
• 函式可作為引數
• 沒有預設引數可選引數
• 有可變引數列表