您当前所在位置：首页 > 脚本专栏 > Golang

Golang

Go语言中函数的使用方法详解

[db:来源] 2023-04-30Golang3117

这篇文章主要为大家具体介绍了Go语言中函数的使用方法的相关资料，文中的示例代码讲解具体，对我们学习Go语言有一定的帮助，感爱好的可以了解一下

函数特点

函数可以有多个返归值。
可以将函数作为参数传递给其他函数。
可以定义匿名函数。
支持闭包。
函数可以有多个参数和多个返归值。
可以使用可变参数。

函数知识点

函数调用：函数调用时需要传递函数定义中要求的参数，并根据需要接收返归值。
匿名函数：匿名函数没有函数名，可以直接定义并调用。常用于函数内部作为闭包使用。
闭包：闭包是指一个函数内部定义的函数，它可以访问外部函数的变量，并将这些变量与函数绑定，形成一个闭合的环境。
可变参数：使用 ... 表示可变参数，可变参数必须放在函数参数列表的最后面，并且只能有一个。
函数作为参数：可以将函数作为参数传递给其他函数，这种函数称为高阶函数。常用于函数式编程中。
函数作为返归值：函数也可以作为返归值，这种函数称为闭包。常用于实现类似于装饰器或者切面等功能。

函数的使用

函数定义

Go语言中函数的定义使用 func 要害字，其基本语法格式如下：

func 函数名(参数列表) (返归值列表) {
函数体
}

其中：

函数名 表示函数的名称，遵循标识符的命名规则，采用驼峰命名法。
参数列表 表示函数的输进参数，用逗号分隔，每个参数由参数名和参数类型组成，如 param1 type1, param2 type2。
返归值列表 表示函数的返归值，用括号括起来，可以是多个返归值，如 (type1, type2)。
函数体 表示函数的详细实现逻辑。

例如，下面是一个计算两个整数之和的函数：

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

上述函数名为 Add，有两个参数 x 和 y，类型都为 int，返归值类型为 int，函数体内部实现为将 x 和 y 相加，并将结果返归。

需要注重的是，Go语言中函数也可以有多个返归值，例如：

func Swap(x, y string) (string, string) {
    return y, x
}

上述函数名为 Swap，有两个参数 x 和 y，类型都为 string，返归值类型为两个 string 类型的值，函数体内部实现为将 x 和 y 的值互换，并将结果以 (y, x) 的形式返归。

函数的参数

函数可以有多个参数，参数的类型放在参数名的后面，假如两个或多个连续的参数的类型相同，则可以省略类型，例如：

func swap(x, y string) (string, string) {
   return y, x
}

函数的返归值

函数可以返归多个值，这些值用括号括起来并用逗号分隔。例如：

func sum(a int, b int) (int, int) {
   return a+b, a-b
}

可以使用 := 赋值语句来调用函数，并自动推断返归值类型：

a, b := sum(1, 2)

函数的参数是值传递，在函数调用时，传递的是实参的副本。

函数的变量作用域

函数中声明的变量作用域是该函数内部，在函数外部是不可见的。假如函数中使用了全局变量，则在函数中可以直接使用。

函数的递回调用

函数可以递回调用，递回调用必须有一个终止条件。例如：

func factorial(n uint64) (result uint64) {
   if (n > 0) {
      result = n * factorial(n-1)
      return result
   }
   return 1
}

函数的可变参数

函数的可变参数是一个非常有用的特性，可以接受任意数量的参数。在参数列表的最后一个参数之前加上省略号 ... 即可：

func sum(numbers ...int) int {
   total := 0
   for _, number := range numbers {
      total += number
   }
   return total
}

函数的闭包

函数的闭包是指函数可以访问其外部作用域中的变量。例如：

func main() {
   nextInt := intSeq()
   fmt.Println(nextInt())
   fmt.Println(nextInt())
   fmt.Println(nextInt())
   newInts := intSeq()
   fmt.Println(newInts())
}
func intSeq() func() int {
   i := 0
   return func() int {
      i += 1
      return i
   }
}

以上代码输出：

1
2
3
1

函数的 defer 语句

在Go语言中，函数的 defer 语句可以在函数返归时执行一些清理工作，如关闭文件、解锁资源等。defer 语句可以被插进到函数的任意位置，并且可以定义多个 defer 语句。在函数执行时，每个 defer 语句都会被压进一个栈中，等待函数返归时逆序执行。

下面是一个使用 defer 语句的例子：

func main() {
    defer fmt.Println("deferred")
    fmt.Println("regular")
}

这个程序输出：

regular
deferred

在这个例子中，当 main 函数执行到 defer 语句时，"deferred" 被压进一个栈中。然后程序继承执行，输出 "regular"。当函数返归时，栈中的 defer 语句被逆序执行，最后输出 "deferred"。

除了可以用来清理资源，defer 语句还可以用来记录函数的执行时间。下面是一个例子：

func timeTrack(start time.Time, name string) {
    elapsed := time.Since(start)
    log.Printf("%s took %s", name, elapsed)
}

func myFunc() {
    defer timeTrack(time.Now(), "myFunc")
    // 函数的实际代码
}

在这个例子中，timeTrack 函数用来记录函数的执行时间。在 myFunc 函数中，defer 语句被用来调用 timeTrack 函数，并传进当前时间和函数名作为参数。当 myFunc 函数返归时，timeTrack 函数被执行，输出函数的执行时间。

总之，在Go语言中，defer 语句是一个非常方便的工具，可以用来清理资源、记录函数的执行时间等。