GO语言笔记--函数

Love The Way You Lie 2022-02-15 23:45 334阅读 0赞

# 1.函数function #

1）Go函数不支持嵌套、重载和默认参数

2）但支持以下特性：无需声明原型、不定长参数、多返回值、命名返回值参数、匿名函数、闭包

3）定义函数只有关键字func，且左大括号不能另起一行

4）函数也可以作为一种类型使用

5）函数可以返回多个值

# 2.defer #

1）执行方式类似其他语言中的析构函数，在函数执行结束后安装调用顺序的相反顺序逐个执行

2）即使函数发生严重错误也会执行

3）支持匿名函数的调用

4）常用于资源清理、文件关闭、解锁以及记录时间等操作

5）如果函数体内某个变量作为defer时匿名函数的参数，则在定义defer时及已经获得了拷贝，否则是引用某个变量的地址

6）Go没有异常机制但有painc/recover模式来处理错误

7）panic可以在任何地方引发，但recover只有在defer调用的函数中有效

## 实例： ##

package main
    
    import (
        "fmt"
    )
    
    func main() {
        var fs = [4]func(){}
        for i := 0; i < 4; i++ {
            defer fmt.Println("defer i = ", i)
            defer func() { fmt.Println("defer_closure i = ", i) }()
            fs[i] = func() { fmt.Println("closure i = ", i) }
        }
    
        for _, f := range fs {
            f()
        }
    }
    输出：
    API server listening at: 127.0.0.1:12291
    closure i = 4
    closure i = 4
    closure i = 4
    closure i = 4
    defer_closure i = 4
    defer i = 3
    defer_closure i = 4
    defer i = 2
    defer_closure i = 4
    defer i = 1
    defer_closure i = 4
    defer i = 0

## 实例二： ##

package main
    
    import (
        "fmt"
    )
    
    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:%s", op)
        }
    }
    
    func div(a, b int) (q, r int) {
        return a / b, a % b
    }
    
    func main() {
        if result, err := eval(3, 4, "X"); err != nil {
            fmt.Println("Error:", err)
        } else {
            fmt.Println(result)
        }
        q, r := div(13, 3)
        fmt.Println(q, r)
    }
    输出：
    API server listening at: 127.0.0.1:6205
    Error: unsupported operation:X
    4 1

## 可变参数实例 ##

package main
    
    import (
        "fmt"
    )
    
    //可变参数就是传入的参数个数是不确定的
    func sum(num ...int) int {
        s := 0
        //由于参数个数不确定因此使用for进行range遍历
        for i := range num {
            s += num[i]
        }
        return s
    }
    
    func main() {
        fmt.Println(sum(1, 2, 3, 4, 5, 6, 7, 8, 9))
        fmt.Println(sum(1))
        fmt.Println(sum(1, 2, 3))
    }
    输出：
    API server listening at: 127.0.0.1:3830
    45
    1
    6

# 3.函数式编程 #

说明：

1）总之参数、变量、返回值都可以是函数

2）在”正统“的函数式编程中具有不可变性，也就是不能有状态，只有常量和函数；函数只能有一个参数，GO语言函数式编程忽略了这些所谓的”正统“思想

如下实例展示了函数式编程，其中涉及到的知识点有反射、闭包、匿名函数等内容

package main
    
    import (
        "fmt"
        "math"
        "reflect"
        "runtime"
    )
    
    //函数式编程，此处op是传入的函数方法也就是func op(a,b int) int {}这样一个形式
    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 %s with argws"+"(%d, %d)", opName, a, b)
        //返回调用函数
        return op(a, b)
    }
    
    func mytest(a, b int) int {
        return a + b
    }
    
    func main() {
        //利用闭包匿名函数，重写math.Pow然后传入到apply
        a := apply(func(a int, b int) int {
            return int(math.Pow(float64(a), float64(b)))
        }, 3, 4)
        fmt.Println(a)
        //传入自定义的函数
        b := apply(mytest, 3, 4)
        fmt.Println(b)
    }
    执行结果：
    API server listening at: 127.0.0.1:3333
    Calling function %s with argws(%d, %d) main.main.func1 3 4
    81
    Calling function %s with argws(%d, %d) main.mytest 3 4
    7

## 累加器实例 ##

package main
    
    import "fmt"
    
    func adder() func(int) int {
        sum := 0
    //这里使用到了一个闭包
        return func(v int) int {
            sum += v
            return sum
        }
    }
    
    func main() {
        a := adder()
        for i := 0; i < 10; i++ {
            fmt.Printf("0 + 1 + ... + %d = %d\n", i, a(i))
        }
    }
    输出：
    API server listening at: 127.0.0.1:21876
    0 + 1 + ... + 0 = 0
    0 + 1 + ... + 1 = 1
    0 + 1 + ... + 2 = 3
    0 + 1 + ... + 3 = 6
    0 + 1 + ... + 4 = 10
    0 + 1 + ... + 5 = 15
    0 + 1 + ... + 6 = 21
    0 + 1 + ... + 7 = 28
    0 + 1 + ... + 8 = 36
    0 + 1 + ... + 9 = 45

上述实例中使用到了闭包

在函数体内闭包由两部分构成：

1）局部变量

2）自由变量，上述sum就是一个自由变量

## 实例，菲波那切数列生成器 ##

package main
    
    import "fmt"
    
    func fibonacci() func() int {
        a, b := 0, 1
        return func() int {
            a, b = b, a+b
            return a
        }
    }
    
    func main() {
        f := fibonacci()
        fmt.Println(f())
        fmt.Println(f())
        fmt.Println(f())
        fmt.Println(f())
        fmt.Println(f())
        fmt.Println(f())
        fmt.Println(f())
        fmt.Println(f())
    }
    输出：
    API server listening at: 127.0.0.1:13243
    1
    1
    2
    3
    5
    8
    13
    21

## 实例，为函数实现接口 ##

package main
    
    import (
        "bufio"
        "fmt"
        "io"
        "strings"
    )
    
    type intGen func() int
    
    func fibonacci() intGen {
        a, b := 0, 1
        return func() int {
            a, b = b, a+b
            return a
        }
    }
    
    func (g intGen) Read(p []byte) (n int, err error) {
        next := g()
        //菲波那切数列不会停止因此这里设置一个数，超过50就停止
        if next > 50 {
            return 0, io.EOF
        }
        s := fmt.Sprintf("%d\n", next)
        return strings.NewReader(s).Read(p)
    }
    
    func testIoReader(reader io.Reader) {
        scanner := bufio.NewScanner(reader)
        for scanner.Scan() {
            fmt.Println(scanner.Text())
        }
    }
    
    func main() {
        f := fibonacci()
        //这样菲波那切数列生成器就可以当作一个文件来读取
        testIoReader(f)
    }
    输出：
    API server listening at: 127.0.0.1:27326
    1
    1
    2
    3
    5
    8
    13
    21
    34

## 实例，使用函数遍历二叉树 ##

tree/tree.go
    
    package tree
    
    import "fmt"
    
    type Node struct {
        Value       int
        Left, Right *Node
    }
    
    
    func (node Node) Print() {
        fmt.Printf("%d ", node.Value)
    }
    
    func CreateNode(value int) *Node {
        return &Node{Value: value}
    }
    
    func (node *Node) Traverse() {
        node.TraverseFunc(func(n *Node) {
            n.Print()
        })
        fmt.Println()
    }
    
    func (node *Node) TraverseFunc(f func(*Node)) {
        if node == nil {
            return
        }
    
        node.Left.TraverseFunc(f)
        f(node)
        node.Right.TraverseFunc(f)
    }

main.go

package main
    
    
    import (
        "fmt"
        "my-code/test-code/tree/tree"
    )
    
    
    func main() {
        var root tree.Node
        root = tree.Node{Value: 3}
        root.Left = &tree.Node{}
        root.Right = &tree.Node{5, nil, nil}
        root.Right.Left = new(tree.Node)
        root.Left.Right = tree.CreateNode(2)
    
    
        root.Traverse()
        //统计节点数
        nodeCount := 0
        root.TraverseFunc(func(node *tree.Node) {
            nodeCount++
        })
        fmt.Println("node count:", nodeCount)
    }
    执行输出：
    API server listening at: 127.0.0.1:31917
    0 2 3 0 5
    node count: 5

GO语言闭包小结：

1）更为自然，不需要修饰如何访问自由变量

2）没有Lambda表达式，但是有匿名函数