Go语言函数学习笔记

go

最近刚刚开始接触Go语言,一下就被它的一些语言特性吸引。对于任何一种编程语言来说函数都是一个不能忽略的话题,这篇文章将简单的讨论Go的函数一些性质。

1.函数定义

1.1.定义格式

  • Go语言中的函数定义格式如下:

    1
    2
    3
    4
    5
    func function_name( [parameter list] ) [return_types] {
    /**
    * function body
    */
    }
    • func:函数由func开始声明。
    • function_name:函数名。
    • parameter list:形参列表。
    • return_types:返回值类型

1.2.一个简单的示例

  • 实现一个简单的加法函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package main
    import "fmt"

    /**
    * 一个简单的加法函数
    */
    func add(num1, num2 int) int {
    return num1 + num2
    }


    func main(){
    a, b := 3, 9
    fmt.Println(add(a, b)) // 12
    }

2.函数调用

  • 与其他一样,用运算符()进行函数调用。

3.函数返回值

  • Go语言中的一个有趣特性就是函数可以有多个返回值

    示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package main
    import "fmt"

    /**
    * 一个除法函数,返回 a 除以 b 的商 和 余数
    */
    func div(a, b int) (int, int) {
    return a / b, a % b
    }


    func main(){
    a, b := div(17, 3)
    fmt.Println(a, b) // 5 2

    a, _ = div(14, 3) //_ 是一个只写变量,不能得到它的值
    fmt.Println(a) // 4

    _, b = div(23, 4)
    fmt.Println(b) // 3
    }

4.函数参数传递

4.1.值传递

  • 值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。

  • 默认情况下,Go 语言使用的是值传递,即在调用过程中不会影响到实际参数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    package main
    import "fmt"

    /**
    * 一个平方函数
    */
    func square(a int) {
    a = a * a
    fmt.Println(a)
    }

    func main(){
    a := 3
    square(a) // 9

    fmt.Println(a) // 3
    }

4.2.引用传递

  • 引用传递是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

  • 使用指针参数传递到函数内。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package main
    import "fmt"

    /**
    * go使用*符号表示指针,使用指针进行引用转递
    */
    func swap(val1, val2 *int){
    var temp int
    temp = *val1
    *val1 = *val2
    *val2 = temp
    }

    func main(){
    a, b := 3, 7
    fmt.Println(a, b) // 3 7

    //利用 & 取地址
    swap(&a, &b)
    fmt.Println(a, b) // 7 3
    }

5.Go语言中函数的用法

5.1.将函数作为值

5.1.1.作为参数

  • 我们可以将函数作为实参传递给一个高阶函数

    考虑用Go实现下面的一般性求和公式:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    package main
    import "fmt"

    /**
    * f 就是公式里的 f, next 表示 变量的增长方式,这两个都是函数形参,a b 就是公式里的 a b
    * 最后返回一个 int类型的值
    */
    func sum(f, next func(int) int, a, b int) int {
    if a > b{
    return 0
    } else{
    //递归
    return f(a) + sum(f, next, next(a), b)
    }
    }

    func main(){
    f := func(x int) int{return x * x}
    getNext := func(x int) int{return x + 2}

    //得到1到100所有奇数的平方和 166650
    fmt.Println(sum(f, getNext, 1, 100))
    }

5.2.闭包

  • Go 语言支持匿名函数,可作为闭包。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    package main
    import "fmt"

    /**
    * 得到一个正整数生成器
    */
    func getIntegers() func() int {
    i := 0
    return func () int {
    i++
    return i
    }
    }

    func main(){
    //生成器a
    integer_a := getIntegers()
    for i := 0; i < 20; i++{
    fmt.Print(integer_a(), " ")
    }

    //生成器 b
    integer_b := getIntegers()
    fmt.Println()
    fmt.Print("得到1到20的奇数序列: ")
    for i := 0; i < 10; i++{
    fmt.Print(integer_b(), " ")
    _ = integer_b()
    }
    }

    运行结果:

    closure

5.3.Go语言中的函数方法

  • Go语言中的一个方法就是一个包含了接受者的函数,接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集,语法格式如下:

    1
    2
    3
    4
    5
    func (variable_name variable_data_type) function_name() [return_type]{
    /**
    * function body
    */
    }
  • 示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    package main
    import (
    "fmt"
    "math"
    )

    //常量 pi
    const pi float64 = 3.14

    // 结构体 圆
    type Circle struct{
    x, y, r float64
    }

    // 求圆面积的方法
    func (c Circle) getArea() float64{
    return c.r * c.r * pi
    }

    // 求两个圆距离的方法
    func (c1 Circle) getDistance(c2 Circle) float64{
    d_x, d_y := c1.x - c2.x, c1.y - c2.y
    return math.Sqrt(d_x * d_x + d_y * d_y)
    }

    func main(){
    var c1 Circle
    c1.x, c1.y, c1.r = 0, 0, 3
    fmt.Println("c1的面积为:", c1.getArea())

    var c2 Circle
    c2.x, c2.y, c2.r = 1.5, 1.5, 2
    fmt.Println("c1到c2的距离为:", c1.getDistance(c2))
    }

    运行结果:

    method

------------- 本文结束 感谢您的阅读 -------------

本文标题:Go语言函数学习笔记

文章作者:Perry

发布时间:2019年04月09日 - 10:33

最后更新:2019年09月19日 - 13:46

原始链接:https://perry96.com/archives/595d6db0.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

0%