您的位置: 首页  >  文章  >  Go语言 - 函数 | 作用域

Go语言 - 函数 | 作用域

分类: 文章 • 2023-11-28 19:51:46

函数是组织好的、可重复使用的、用于执行指定任务的代码块。本文介绍了Go语言中函数的相关内容。

 介绍

Go语言中支持函数、匿名函数和闭包，并且函数在Go语言中属于“一等公民”。

  • 函数可以赋值给变量
  • 函数可以被当做参数传入函数
  • 函数可以被调用

函数定义

Go语言中定义函数使用func关键字，具体格式如下：

func 函数名(参数)(返回值){
    函数体
}
//  函数可以无参数, 无返回值
  • 函数名：由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名也称不能重名（包的概念详见后文）。
  • 参数：参数由参数变量和参数变量的类型组成，多个参数之间使用,分隔。
  • 返回值：返回值由返回值变量和其变量类型组成，也可以只写返回值的类型，多个返回值必须用()包裹，并用,分隔。
  • 函数体：实现指定功能的代码块。
// 定义函数
func seyHello()  {
    fmt.Println("hello func")
}
func intSum(x int, y int) int {
    return x + y
}

函数调用

func main()  {
    // 函数调用
    seyHello()  // hello func
    res := intSum(1, 2)  // 传参
    fmt.Println(res)  // 3
}

注意，调用有返回值的函数时，可以不接收其返回值。

 参数

  • 同类型参数简写

函数的参数中如果相邻变量的类型相同，则可以省略类型，例如：

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

上面的代码中，intSum函数有两个参数，这两个参数的类型均为int，因此可以省略x的类型，因为y后面有类型说明，x参数也是该类型。

  •  可变参数

可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加...来标识。

注意：可变参数通常要作为函数的最后一个参数。

func intSum1(x ...int) int {
    fmt.Printf("%T \n", x)  // []int
    sum := 0
    for _, v := range x{
        sum = sum + v
    }
    return sum
}
func main()  {
    res1 := intSum1(1, 2, 3)
    fmt.Println(res1)  // 6
}

固定参数搭配可变参数使用时，可变参数要放在固定参数的后面，示例代码如下：

func intSum2(x int, y ...int) int {
    fmt.Printf("%T \n", y)  // []int
    sum := 0
    for _, v := range y{
        sum = sum + v
    }
    return sum
}
func main()  {
    res2 := intSum2(0)  // x=0, y=[]
    res3 := intSum2(0, 1 )  // x=0, y=[1]
    res4 := intSum2(0, 1, 2, 3)  // x=0, y=[1 2 3]
    fmt.Println(res2, res3, res4)  // 0 1 6
}

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

 返回值

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

  • 多返回值

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

func ret(x, y int) (int, int) {
    sum := x + y
    sub := x - y
    return sum, sub
}
func main()  {
    res, res1 := ret(5, 3)
    fmt.Println(res, res1)  // 8 2
}

  • 返回值命名

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

func calc(x, y int) (sum, sub int) {
    sum = x + y
    sub = x - y
    return
}

函数作为变量的值

func test()  {
    x := 10
    fmt.Println(x)
}
func main()  {
    f := test
    fmt.Printf("%T \n", f)  // func()
    f()  // 10
}

函数作为参数

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

func test1(x, y int, op func(int, int)int) int {
    return op(x, y)
}

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

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指令执行前。具体如下图所示：

Go语言 - 函数 | 作用域

 面试题1

Go语言 - 函数 | 作用域Go语言 - 函数 | 作用域
func f1() int {
    x := 5
    defer func() {
        x++
    }()
    return x
}

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

func f3() (y int) {
    x := 5
    defer func() {
        x++
    }()
    return x
}
func f4() (x int) {
    defer func(x int) {
        x++
    }(x)
    return 5
}
func main() {
    fmt.Println(f1())
    fmt.Println(f2())
    fmt.Println(f3())
    fmt.Println(f4())
}
结果: 5 6 5 5
View Code

面试题2

Go语言 - 函数 | 作用域Go语言 - 函数 | 作用域
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 = 20
}
View Code

 

变量作用域

  • 全局变量

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

package main

import "fmt"

var a = 10
func test()  {
    // 先在函数内部作用域查找变量
    // 再到全局作用域查找变量
    fmt.Println(a)  
}

func main()  {
    test()  // 10
}

  • 局部变量

 局部变量只能在局部使用,外部若想使用局部变量,需要通过返回值的形式拿到变量的值再使用

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

func main() {
    testLocalVar()
    fmt.Println(x) // 此时无法使用变量x
}

接下来我们来看一下语句块定义的变量，通常我们会在if条件判断、for循环、switch语句上使用这种定义变量的方式。

func test1(x, y int)  {
    fmt.Println(x, y)  //函数的参数也是只在本函数中生效
    if x > 0 {
        z := y
        fmt.Println(z)  //变量z只在if语句块生效
    }
    fmt.Println(z)  //此处无法使用变量z
}

还有我们之前讲过的for循环语句中定义的变量，也是只在for语句块中生效：

func test2()  {
    for i :=0; i < 10; i++{
        fmt.Println(i)  //变量i只在当前for语句块中生效
    }
    fmt.Println(i)  //此处无法使用变量i
}

 

相关推荐