20、Go 函数- 函数声明与参数

hi，我是温新

函数是一种组织好的、可重复使用的、用来实现单一或相关功能的代码段。

Go 语言支持普通函数、匿名函数、闭包函数。

普通声明函数

Go 语言中，声明一个函数使用 func 关键字，后面紧跟函数名、参数列表、返回参数列表及函数体，如下：

func 函数名(参数列表)(返回参数列表) {
    // 函数体
}

函数名：由字母、数字、下划线组成。函数的第一个字母不能为数字。在同一个包内，函数名不能重复。

参数列表：形式为 (a int, b string)

返回参数列表：杺是返回值类型列表，也可以是参数列表中变量名和类型名的组合。

声明函数

package main

import "fmt"

func main() {
	fmt.Println(demoAdd(1, 1))
}

func demoAdd(a int, b int) int {
	return a + b
}

定义一个 demoAdd 函数，其参数 a 和 b 为 int 类型，函数返回值为 int 类型。

函数参数

函数可以有一个或多个参数，每个参数后面带有类型，参数之间通过逗号分隔。若参数中有多个相邻参数是同类型，则参数列表中前面的类型可以省略。如下：

// a、b 类型相同，前面的类型可以省略
func demoAdd(a, b int) int {
    return a + b
}

可变量参数

Go 语言支持可变参数的特性，即函数声明时可以没有固定数量的参数。

可变参数格式如下：

func 函数名(固定参数列表,v ...T) (返回参数列表) {
}

v...T 表示变量 v 是 T 类型的切片。

package main

import "fmt"

func main() {
    fmt.Println("和为 ", demoSum(1, 2, 3, 4, 5, 6, 7, 8))
}

func demoSum(sliceNumber ...int) int {
    sum := 0
    for _, val := range sliceNumber {
        sum = sum + val
    }

    return sum
}

函数返回值

返回值就是函数执行后返回的内容，函数可以有多个返回值，返回值也需要指定类型。

1、无返回值

package main

import "fmt"

func main() {
    demoAdd1(1, 2)
}

func demoAdd1(a, b int) {
    fmt.Println(a + b)
}

2、返回同一种类型

func main() {
    a, b := demoFunc1()
    fmt.Println(a, b)
}

// 返回同一种类型
func demoFunc1() (int, int) {
    return 1, 2
}

3、带有变量名的返回值

func main() {
    fmt.Println(demoFunc2())
}

func demoFunc2() (a, b int) {
    a = 1
    b = 2

    return
}

函数调用

函数调用格式如下：

返回值变量列表 = 函数名(参数列表)

函数名：需要调⽤的函数名。 ·

参数列表：参数变量以逗号分隔，尾部⽆须以分号结尾。 ·

返回值变量列表：多个返回值使⽤逗号分隔。

package main

import "fmt"

func main() {
    c, d := demoFunc2()
    fmt.Println(c, d)
}

func demoFunc2() (a, b int) {
    a = 1
    b = 2

    return
}

_ 忽略返回值

有时候函数返回的值，不想接收，那么可以使用 _ 符号跳过。

package main

import "fmt"

func main() {
    // 只接收第二个返回值
    _, b := demoFunc3()
    fmt.Println(b)
}

func demoFunc3() (int, int) {
    return 1, 2
}

函数类型作为参数传递

在 Go 中，函数类型指的是指定函数的输入和输出参数类型的函数签名。可以把函数类型作为参数传递给函数，然后在函数中调用该函数。

如下案例中，接收一个字符串作为作为参数的函数类型作为参数传递给另一个函数，并在该函数中调用该函数类型。

package main

import "fmt"

func main() {
	demoFunc5(demoFunc6, "Go")
}

// 定义一个接收字符串作为参数的函数类型
type stringParamFunc func(string) string

// 定义一个函数，该函数接收一个 stringParamFunc 类型的参数和一个字符串
func demoFunc5(f stringParamFunc, str string) {
    result := f(str)
    fmt.Println(result)
}

// 定义一个函数，该函数接受一个字符串并返回一个字符串，用于作为 stringParamFunc 类型的参数
func demoFunc6(str string) string {
    return str + " - 函数作为参数传递"
} 

代码解释：

1、使用 type 定义一个返回 string 类型的函数 stringParamFunc；

2、定义一个普通函数 demoFunc5，该参数接收一个 stringParamFunc 类型的参数和一个字符串，并在函数内部使用该函数类型；

3、定义一个普通函数 demoFunc6，接收一个字符串类型的参数，并返回新的数据；

4、在主函数 main 中调用普通函数 demoFunc5，并传入两个参数。

函数作为另外一个函数实参

在 Go 中，函数也可以作为一另外一个函数的实参传入。

package main

import (
	"fmt"
	"strings"
)

func main() {
    printString("Hello go", toUpperCase)
    printString("HELLO GO", toLowerCase)
}

func printString(str string, fn func(string) string) {
    result := fn(str)
    fmt.Println(result)
}

// 将字符串转为大写
func toUpperCase(str string) string {
    return strings.ToUpper(str)
}

// 将字符串转为小写
func toLowerCase(str string) string {
    return strings.ToLower(str)
}

输出结果：

HELLO GO
hello go

代码解释：

1、定义两个普通函数 toUpperCase 和 toLowerCase；

2、定义一个普通函数 printString，接收一个字符串和参数作为参数