Go语言学习之——函数

1、基础类型

package main
​
import "fmt"
​
//名在前，类型在后，同类型可以:a,b int
func eval( a,b int, op string ) int{
    switch op{
    case "+":
        return a+b
    case "-":
        return a-b
    case "*":
        return a*b
    case "/":
        return a/b
    default:
        panic("unsupported operation: " + op)
    }
}
​
func main() {
    fmt.Println( eval(3,5,"*") )
}

2、可以返回多个值

package main
​
import "fmt"
​
//带余除法:13 / 4 = 3...1
func div( a,b int ) ( int, int ){
    return a/b, a%b
}
​
func main() {
    fmt.Println( div(13,4) )
}
一般多返回值用来返回错误
package main
​
import "fmt"
​
//返回了结果和error
func eval( 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, _ := div(a,b)
        return q, nil
    default:
        return 0, fmt.Errorf("unsupported operation: " + op)
    }
}
​
func div( a,b int ) ( q,r int ){
    return a/b, a%b
}
​
func main() {
    fmt.Println( eval(13,2, "=") ) // output: 0 unsupported operation: =
    if result, err := eval(13,4,"x" ); err != nil{
        fmt.Println("Error:", err )
    }else{
        fmt.Println(result)
    } // output: Error: unsupported operation: x
    fmt.Println( eval(13,2, "/") ) // output: 6 <nil>
}

3、可以给返回值取名字，一般用于简单的函数

package main
​
import "fmt"
​
//可以给返回值取名字
func div( a,b int ) ( q,r int ){
    return a/b, a%b
}
​
func main() {
    q, r := div(13,4) //因为函数返回值有名字，那么编译器自动生成名字时就会生成和函数返回值一样的名字，虽然不知道快捷键是啥。。。
    fmt.Println(q, r)
}

4、多个返回值时，如果只想接收一个返回值，另外一个返回值不用，可以使用_

package main
​
import "fmt"
​
//名在前，类型在后，同类型可以:a,b int
func eval( a,b int, op string ) int{
    switch op{
    case "+":
        return a+b
    case "-":
        return a-b
    case "*":
        return a*b
    case "/":
        q, _ := div(a,b) //这里不可以写q, r := div(a,b)，因为定义r却不使用是不允许的
        return q
    default:
        panic("unsupported operation: " + op)
    }
}
​
//带余除法:13 / 4 = 3...1
//可以给返回值取名字
func div( a,b int ) ( q,r int ){
    return a/b, a%b
}
​
func main() {
    fmt.Println( eval(13,2, "/") )
}

5、go语言函数式编程，函数可以作为参数

ackage main
​
import (
    "fmt"
    "reflect"
    "runtime"
    "math"
)
​
func apply( op func( int, int) int, a,b int) int {
    p := reflect.ValueOf(op).Pointer()
    opName := runtime.FuncForPC(p).Name() //获得函数名
    fmt.Printf("Calling function %s with args " + "(%d,%d)\n", 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) ) // output: Calling function main.pow with args (3,4)   81
}

6、匿名函数

package main
​
import (
    "fmt"
    "reflect"
    "runtime"
    "math"
)
​
func apply( op func( int, int) int, a,b int) int {
    p := reflect.ValueOf(op).Pointer()
    opName := runtime.FuncForPC(p).Name() //获得函数名
    fmt.Printf("Calling function %s with args " + "(%d,%d)\n", opName, a, b ) //打印函数名和参数
    return op( a, b )
}
​
func main() {
    // apply第一个参数可以使用匿名函数
    fmt.Println( apply( func(a,b int) int{
        return int( math.Pow( float64(a), float64(b) ) )
    }, 3,4) ) // output: Calling function main.main.func1 with args (3,4)  81
}

7、可变参数列表

package main

import "fmt"

func sum( numbers ...int ) int {
    s := 0
    for i := range numbers {
        s += numbers[i]
    }
    return s
}

func main() {
    fmt.Println( sum( 1,2,3,4,5 ) )
}