August Rush

一个还在努力成长的小火汁！

游龙当归海，海不迎我自来也。

We create our own demons.

You can reach me at augustrush0923@gmail.com
Go语言基础-函数
发布：2021年02月18日 | 作者：augustrush | 阅读量: 1090

在Go语言中，函数可以分为两种：

  • 带有名字的普通函数
  • 没有名字的匿名函数

由于Go语言是编译型语言，所有函数编写的顺序是无关紧要的，它不像Python那样，函数在位置上需要定义在调用之前。


函数的定义

函数的定义，使用func关键字，后面依次接函数名，参数列表,返回值列表,用{}包裹的代码逻辑体

func 函数名(形式参数列表) (返回值列表) {
    函数体
}

  • 函数名必须由字母、数字、下划线组成。函数名的第一个字母不能是数字。在同一个包内，函数名也不能重名

  • 形式参数列表描述了函数的参数名以及参数类型，这些参数作为局部变量，其值由函数调用者提供

  • 返回值列表描述了函数返回值的变量名以及类型，如果函数返回一个无名变量或者没有返回值，返回值列表的括号是可以省略的。多个返回值必须用()包裹，并用,分割。

  • 函数体是实现指定功能的代码块。

一个无参数无返回值的函数：

func sayHello() {
    fmt.Println("Hello 小姐姐")
}

定长参数和一个返回值的函数：

func numSum(x int, y int) int {
    return x + y
}


函数的调用

定义了函数之后，我们可以通过函数名()的方式调用函数。

func main() {
    sayHello()
    ret := numSum(10, 20)
    fmt.Println(ret)
}


函数的参数

在Python中可以使用*args和**kwargs来实现可变参数。

Go可变参数分为以下两种：

  • 多个类型一致的参数

  • 多个类型不一致的参数

多个类型一致的参数

对于多个类型一致的参数，可以使用...表示一个类型的切片。

package main

import "fmt"

func main() {
    ret1 := Sum(1)
    ret2 := Sum(1, 2)
    ret3 := Sum(1, 2, 3)
    ret4 := Sum(1, 2, 3, 4)
    fmt.Println(ret1, ret2, ret3, ret4)
}

func Sum(x ...int) int {
    sum := 0
    fmt.Println(x)
    for _, item := range x {
        sum += item
    }
    return sum
}

多个类型不一致的参数

当希望传多个参数且这些参数的类型都不一样，可以指定类型为...interface{},然后再遍历。

import "fmt"
func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) {
            case int:
                fmt.Println(arg, "is an int value.")
            case string:
                fmt.Println(arg, "is a string value.")
            case int64:
                fmt.Println(arg, "is an int64 value.")
            default:
                fmt.Println(arg, "is an unknown type.")
        }
    }
}

func main() {
    var v1 int = 1
    var v2 int64 = 234
    var v3 string = "hello"
    var v4 float32 = 1.234
    MyPrintf(v1, v2, v3, v4)
}

本质上，函数的可变参数是通过切片来实现的。


函数的返回值

Go语言通过return关键字向外输出返回值。

多返回值

Go语言中函数支持多返回值，函数如果有多个返回值时必须用()将所有返回值包裹起来。

func getInfo() (string, int) {
    name := "August Rush"
    age := 18
    return name, age
}

返回值命名

函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回。

func getInformation() (name string, age int) {
    name = "August Rush"
    age = 18
    return
}

返回值补充

当我们的一个函数返回值类型为slice时，nil可以看做是一个有效的slice，没必要显示返回一个长度为0的切片。

func someFunc(x string) []int {
    if x == "" {
        return nil
    }
    ...
}


函数进阶

变量作用域

全局变量

全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。在函数中可以访问到全局变量。

package main

import "fmt"

//定义全局变量num
var num int64 = 10

func testGlobalVar() {
    fmt.Printf("num=%d\n", num) //函数中可以访问全局变量num
}
func main() {
    testGlobalVar() //num=10
}

局部变量

局部变量分为两种情况：

  • 函数内定义的变量无法在该函数外使用
func testLocalVar() {
    //定义一个函数局部变量x,仅在该函数内生效
    var x int64 = 100
    fmt.Printf("x=%d\n", x)
}

func main() {
    testLocalVar()
    fmt.Println(x) // 此时无法使用变量x
}
  • 如果局部变量和全局变量重名，优先访问局部变量。
package main

import "fmt"

//定义全局变量num
var num int64 = 10

func testNum() {
    num := 100
    fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量
}
func main() {
    testNum() // num=100
}

简单来说局部变量生效在语句块内{},在语句块内优先使用语句块内的变量，如果语句块内没有该变量，会向上级语句块查找，直到找到全局变量。如果依然没有，则就会报错。

if条件判断、for循环、switch语句中定义的变量，只在其语句块中生效。

函数类型与变量

定义函数类型

我们可以使用type关键字来定义一个函数类型，具体格式如下：

type calculation func(int, int) int

上面语句定义了一个calculation类型，它是一种函数类型，这种函数接收两个int类型的参数并且返回一个int类型的返回值。

简单来说，凡是满足这个条件的函数都是calculation类型的函数，例如下面的add和sub是calculation类型。

func add(x, y int) int {
    return x + y
}

func sub(x, y int) int {
    return x - y
}

add和sub都能赋值给calculation类型的变量。

var c calculation
c = add
fmt.Println(c(1, 2))

函数类型变量

我们可以声明函数类型的变量并且为该变量赋值：

func main() {
    var c calculation               // 声明一个calculation类型的变量c
    c = add                         // 把add赋值给c
    fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
    fmt.Println(c(1, 2))            // 像调用add一样调用c

    f := sub                        // 将函数sub赋值给变量f
    fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
    fmt.Println(f(10, 20))          // 像调用sub一样调用f
}


高阶函数

函数作为参数

//func calc(x int, y int, op calculation) int {
//  return op(x, y)
//}

func add(x, y int) int {
    return x + y
}
func calc(x, y int, op func(int, int) int) int {
    return op(x, y)
}

func main() {
    res := calc(10, 20, add)
    fmt.Println(res)
}

函数作为返回值

// func someFunc(s string) (op calculation, err error)
func someFunc(s string) (func(int, int)int , err error) {
    switch s {
    case "+":
            return add,nil
    case "-":
            return sub.nil
    default:
        err := errors.New("无法识别的操作符")
        return nil, err
    }
}


匿名函数和闭包

匿名函数

匿名函数就是没有函数名的函数，匿名函数的定义格式如下：

func(参数)(返回值){
    函数体
}

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行的函数：

func main(){
    // 将匿名函数保存到变量
    add := func(x, y int) {
        fmt.Println(x + y)
    }
    add(10, 20) // 通过变量调用匿名函数

    // 自执行函数：匿名函数定义完加()直接执行
    func(x, y int) {
        fmt.Println(x + y)
    }(10, 20)
}

匿名函数多用于实现回调函数和闭包。

闭包

闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境。

闭包的本质： 闭包的本质依旧是一个匿名函数，只是这个函数引入外界的变量/参数

闭包的特点： 1. 返回的是一个匿名函数，但是这个匿名函数引用到函数外的变量/参数，因此这个匿名函数就和变量/参数形成一个整体，构成闭包。 2. 闭包中使用的变量/参数会一直保存在内存中，所以可以一直使用。就可能导致内存溢出，需要谨慎使用。

func adder() func(int) int {
    var x int
    return func(y int) int {
        x += y
        return x
    }
}

func main() {
    f := adder()
    fmt.Println(f(10)) //10
    fmt.Println(f(20)) //30
    fmt.Println(f(30)) //60

    f1 := adder()
    fmt.Println(f1(10)) //10
    fmt.Println(f1(20)) //30
}

变量f是一个函数并且它引用了其外部作用域的x变量，此时f就是一个闭包。在f的生命周期内，变量x也一直有效。

闭包进阶示例1：

func adder(x int) func(int) int {
    return func(y int) int {
        x += y
        return x
    }
}

func main() {
    f := adder(10)
    fmt.Println(f(10)) //20
    fmt.Println(f(20)) //40
    fmt.Println(f(30)) //70

    f1 := adder(20)
    fmt.Println(f1(10)) //30
    fmt.Println(f1(20)) //50
}

闭包进阶示例2：

func makeSuffixFunc(suffix string) func(name string) string{
    return func(name string) string {
        if !strings.HasSuffix(name, suffix){
            return name + suffix
        }
        return name
    }
}


func main() {
    jpgFunc := makeSuffixFunc(".jpg")
    txtFunc := makeSuffixFunc(".txt")
    fmt.Println(jpgFunc("test")) // test.jpg
    fmt.Println(txtFunc("test")) // text.txt
}

闭包进阶示例3：

func main() {
    f1, f2 := calc(10)
    fmt.Println(f1(1), f2(2)) // 11 9
}


defer语句

Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。

func main() {
    fmt.Println("start")
    defer fmt.Println(1)
    defer fmt.Println(2)
    defer fmt.Println(3)
    fmt.Println("end")
}

/*
输出结果：
        start
        end
        3
        2
        1
*/

由于defer语句延迟调用的特性，所有defer语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。

defer执行时机

在Go语言中的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后，RET指令执行前。

defer在命名返回值和匿名返回值 函数中表现是不一样的

匿名返回值

func f1() int {
    var a = 0  // 0
    defer func () {
        a++ // a=1
    }()
    return a //int = 0
}

// 输出结果： 0

在匿名返回值里返回的值与defer操作之后的值无关，简单来说就是返回defer操作之前的值。

命名返回值

func f2() (x int) {
    defer func(){
        x++ // x=1
    }()
    return x // x=0
}

// 输出结果：1

在命名返回值里返回的值是defer操作之后的值。

func f1() int {
    var x int
    defer func(){
        x++
    }()
    return x
}

func f2() (x int){
    defer func() {
        x++
    }()
    return x
}

func f3() (y int){
    var x = 5
    defer func(){
        x++
    }()
    return x
}

func f4() (x int) {
    defer func(x int) { 
        // fmt.Println(x) // 这里打印x时。返回的是0
        x++ // x=1 但这里的x作用域就在这个函数内
    }(x) // defer注册延迟执行的函数时该函数所有的参数都需要确定其值。
    return 5
}

func main() {
    fmt.Println(f1())
    fmt.Println(f2())
    fmt.Println(f3())
    fmt.Println(f4())
}

defer注册延迟执行的函数时该函数所有的参数都需要确定其值。

func calc(index string , a,b int) int {
    ret := a+b
    fmt.Println(index, a, b, ret)
    return ret
}

func main() {
    x := 1
    y := 2
    defer calc("AA", x, calc("A", x, y))
    x = 10
    defer calc("BB", x, calc("B", x, y))
    y = 10
}


内置函数panic/recover

Go语言中目前（Go1.12）是没有异常机制，但是可以使用panic/recover模式来处理异常。

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

一个简单的例子：

func funcA() {
    fmt.Println("func A")
}

func funcB() {
    panic("panic in B")
    fmt.Println("func B")
}

func funcC() {
    fmt.Println("func C")
}

func main() {
    funcA()
    funcB()
    funcC()
}

/*
输出结果：
        func A
        panic: panic in B

        goroutine 1 [running]:
        main.funcB(...)
                .../code/func/main.go:12
        main.main()
                .../code/func/main.go:20 +0x98
*/

程序运行期间funcB中引发了panic导致程序崩溃，异常退出了。这个时候我们就可以通过recover将程序恢复回来，继续往后执行。

func funcA() {
    fmt.Println("func A")
}

func funcB() {
    defer func() {
        err := recover()
        // 如果程序报错，err不为nil
        if err != nil{
            fmt.Println("recover in B")
        }
    }
    panic("panic in B")
    fmt.Println("func B") // 不可到达的代码
}

func funcC() {
    fmt.Println("func C")
}

func main() {
    funcA()
    funcB()
    funcC()
}

/*
输出结果：
        func A
        recover in B
        func C
*/

recover必须搭配defer使用。

defer一定要在可能引发panic的语句之前定义。

func calc(a, b int) int {
    defer func() {
        err := recover()
        if err != nil {
            fmt.Println("除数不能为0")
        }
    }()
    return a/b
}

func main() {
    fmt.Println(calc(10, 0))
    fmt.Println(calc(10, 2))
}
/*
输出结果：
        除数不能为0
        5
*/

func readFile(fileName string) error {
    if fileName != "main.go" {
        return errors.New("文件无法读取")
    }
    return nil
}

func readFunc() {
    defer func() {
        err := recover()
        if err != nil {
            fmt.Println("给管理员发邮件")
        }
    }()

    err := readFile("小姐姐.avi")
    if err != nil {
        panic(err)
    }
}
func main() {
    readFunc()
}
// 输出结果：给管理员发邮件
上一篇:Go语言基础-指针 下一篇:Go语言基础-结构体


  • 标签云

  • 支付宝扫码支持一下

  • 微信扫码支持一下


基于Nginx+Supervisord+uWSGI+Django1.11.1+Python3.6.5构建

京ICP备20007446号-1 & 豫公网安备 41100202000460号

网站地图 & RSS | Feed