当前位置：首页 > news >正文

go函数详解

news 来源：原创 2025/5/18 9:13:02

1.简介

函数是组织好的、可重复使用的，用于执行指定任务的代码块，为了完成某一个功能的程序指令的集合，称为函数。go语言中支持：函数、匿名函数和闭包。

2.函数的定义

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

函数体

return 返回值列表

}

其中：

函数名：由字母、数字、下划线组成。但函数名第一个字母不能是数字。在同一个包内，函数名也不能重名。
形参列表：参数由参数变量和参数变量的类型组成，做个参数之前是用逗号分割。
返回值：返回值由返回之变量和其类型组成，也可以只写返回值的类型，多个返回值必须用（）包裹，并用逗号分隔。
函数体：实现指定功能的代码块。

3.基本用法

3.1函数的基本用法

函数的参数和返回值都是可选的，例如我们可以实现一个即不需要参数也不需要返回值的函数：

func sayHello() {
	fmt.Println("sayhello")
}

3.2求两个数的和

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

调用：

func main() {
	sum := sumFn(10, 13)
	fmt.Println(sum)
}

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

3.3函数简写（求两个数的差）

函数的参数中如果相邻变量的类型相同，则可以省略类型，例如下面代码中，subFn函数有两个参数，这两个参数的类型相同，因此可以省略a的类型，因为b后面有类型说明，a参数也是该类型。

func subFn(a, b int) int {
	return a - b
}

3.4可变参数

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

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

func changFn(a int, x ...int) int {
	fmt.Printf("%v--%T\n", x, x)
	var sum = a
	for _, v := range x {
		sum += v
	}
	return sum
}

调用

func main() {
	changSum := changFn(1, 2, 3, 4, 5, 6)
	fmt.Println(changSum)
}

结果：

[2 3 4 5 6]--[]int
21

3.5函数返回值

go语言中通过return关键字向外输出返回值。上面代码已经体验函数单个返回值的用法了。

go语言中的函数还支持多返回值，函数如果有多个返回值时必须用（）将所有的返回值包裹起来。

func moreFn(a, b int) (int, int) {
	sum := a + b
	sub := a - b
	return sum, sub
}
func main() {	 
	msum, msub := moreFn(20, 13)
	fmt.Println(msum, msub)
}

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

func moreFn2(a, b int) (sum, sub int) {
	sum = a + b
	sub = a - b
	return
}
func main() {
	msum, msub := moreFn2(20, 17)
	fmt.Println(msum, msub)
}

4.函数变量作用域

全局变量：全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。全局作用域。

局部变量：局部变量是在函数内部定义的变量，函数内定义的变量无法在函数外部使用。局部变量。

注意：如果全局变量和局部变量重名了，优先访问局部变量。

var a = "全局变量"

func run() {
	var b="局部变量"
	fmt.Println("run--a=", a)
	fmt.Println("run--b=",b)


}
func main() {
	run()
	fmt.Println("main--a=", a)
	//i是局部变量，只能在for内部使用
	for i := 0; i < 10; i++ {
		fmt.Println(i)
		
	}
}

5.练习

5.1封装整数类型的切片排序方法

要求：选择排序，从小到大。

func sortIntAsc(slice []int) []int {
	for i := 0; i < len(slice); i++ {
		for j := i + 1; j < len(slice); j++ {
			if slice[i] > slice[j] {
				slice[i], slice[j] = slice[j], slice[i]
			}
		}
	}
	return slice
}
func main() {
	sliceA := []int{23, 1, 5, 67, 13, 22}
	fmt.Println(sortIntAsc(sliceA))
	fmt.Println(sliceA)
}

结果：因为切片是引用类型的数据，所以两次结果是一致的。

[1 5 13 22 23 67]
[1 5 13 22 23 67]

5.2要求把map按照key的顺序进行打印

例如：

var m1 map[string]string
m1 = make(map[string]string)
m1["username"] = "张三"
m1["age"] = "18"
m1["height"] = "1.8"
m1["sex"] = "男"

打印结果：age=>18height=>1.8sex=>男username=>张三

func sortMap(m map[string]string) string {
	var slice []string
	for key, _ := range m {
		slice = append(slice, key)
	}
	sort.Strings(slice)
	var str string
	for _, s := range slice {
		str += fmt.Sprintf("%v=>%v", s, m[s])
	}
	return str
}
func main() {
	var m1 map[string]string
	m1 = make(map[string]string)
	m1["username"] = "张三"
	m1["age"] = "18"
	m1["height"] = "1.8"
	m1["sex"] = "男"
	str := sortMap(m1)
	fmt.Println(str)
}

6.函数类型与变量

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

type 类型名称 func(参数类型，参数类型。。。) 返回值类型

例如

type calculation func(int,int) int

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

package main

import "fmt"

// 定义函数类型
type calculation func(int, int) int

func add(a, b int) int {
	return a + b
}
func sub(a, b int) int {
	return a - b
}
func main() {
	var c calculation
	c = add
	fmt.Printf("%T\n", c)
	fmt.Println(c(2, 4))
	f := sub
	fmt.Printf("%T\n", f)
	fmt.Println(f(10, 2))
}

结果：

main.calculation
6
func(int, int) int
8

由上面结果可知，add和sub函数都满足接收两个int类型的参数并且都返回一个int类型的值，所以可以把赋值给calculation类型的变量。

7.把函数作为参数

package main

import "fmt"

// 定义函数类型
type calculation func(int, int) int

func add(a, b int) int {
	return a + b
}
func sub(a, b int) int {
	return a - b
}
func fn1(a, b int, do calculation) int {
	return do(a, b)
}
func fn2(a, b int, do func(int, int) int) int {
	return do(a, b)
}
func main() {
	fmt.Println(fn1(1, 2, add))
	fmt.Println(fn2(12, 2, sub))
}

结果：

3
10

8.把函数当作返回值

package main

import "fmt"

// 定义函数类型
type calculation func(int, int) int

func add(a, b int) int {
	return a + b
}
func sub(a, b int) int {
	return a - b
}
func cal(s string) calculation {
	switch s {
	case "+":
		return add
	case "-":
		return sub
	case "*":
		return func(i int, i2 int) int {
			return i * i2
		}
	default:
		return nil

	}
}
func main() {
	sum := cal("+")
	fmt.Println(sum(1, 2))
	fmt.Println(cal("-")(12, 10))
	fmt.Println(cal("*")(3, 10))
}

结果：

3
2
30

9.匿名函数

函数当然还可以作为返回值，但是在Go语言中函数内部不能再像之前那样定义函数了，只能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下：

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

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

package main

import "fmt"

func main() {
	func() {
		fmt.Println("hello word")
	}()
	//将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) //通过变量调用匿名函数
	//自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)

}

结果：

hello word
30
30

10.闭包

闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。或者说是函数和其引用环境的组合体。首先我们来看一个例子：

package main

import "fmt"

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60
	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}

结果：