Go语言学习(二) 函数

函数

go函数基本语法

先来看看go中函数的基本使用

package main

import "fmt"

/*
func 函数名(形参列表) (返回值类型列表) {
	执行语句..
	return + 返回值列表
}
*/
//自定义函数：功能：两个数相加：
func cal(num1 int, num2 int) int { //如果返回值类型就一个的话，那么()是可以省略不写的
	var sum int = 0
	sum += num1
	sum += num2
	return sum
}

func cal2(num1 int, num2 int) (int, int) { //如果返回值类型就一个的话，那么()是可以省略不写的
	var sum int = 0
	sum += num1
	sum += num2
	var res int = num1 - num2
	return sum, res
}

func main() {
	// var num1 int = 10
	// var num2 int = 20
	// //求和
	// var sum int = 0
	// sum += num1
	// sum += num2
	// fmt.Println(sum)
	sum := cal(10, 20)
	fmt.Println(sum)

	sum1, res1 := cal2(10, 20)
	fmt.Println(sum1)
	fmt.Println(res1)
	// var num3 int = 30
	// var num4 int = 50

	// var sum1 int = 0
	// sum1 += num3
	// sum1 += num4
	// fmt.Println(sum1)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

再来看一个demo，思考为什么交换之后输出的值还是一样呢？

package main

import "fmt"

//自定义函数：功能：交换两个数
func exchangeNum (num1 int, num2 int) {
	var t int
	t = num1
	num1 = num2
	num2 = t
}

func main() {
	//调用函数：交换10和20
	var num1 int = 10
	var num2 int = 20
	fmt.Printf("交换前的两个数：num1 = %v, num2 = %v \n",num1, num2)
	exchangeNum(num1,num2)
	fmt.Printf("交换后的两个数：num1 = %v, num2 = %v \n",num1, num2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

相信大家也思考了一下，那接下来我们来看看这个程序的内存分析

go不支持重载

go中支持可变参数

如果你希望函数带有可变数量的参数

我们有其他语言功底的话先把切片当作数组看待，程序执行结果
基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值

以值传递的方式的数据类型，如果希望在函数内的变量能修改函数外的变量，可以传入变量的地址&，函数以内指针的方式操作变量。从效果来看类似引用传递

在Go中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用

package main

import "fmt"

//在Go中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。
//通过该变量可以对函数调用
func test(num int) {
	fmt.Println(num)
}

//定义一个函数，把另一个函数作为参数
func test02(num1 int, num2 float32, testFunc func(int)) {
	fmt.Println("----test02")
}

type myFunc func(int)

func test03(num1 int, num2 float32, testFunc myFunc) {
	fmt.Println("----test03")
}

func main() {
	//函数也是一种数据结构，可以赋值给一个变量
	a := test //变量就是一个函数类型的变量
	fmt.Printf("a的类型是：%T,test函数的类型是：%T", a, test)
	//a的类型是：func(int),test函数的类型是：func(int)
	a(10) //等价于 test(10)

	//调用test02函数
	test02(10, 3.14, test)
	test02(10, 3.14, a)

	//自定义数据类型：(相当于起别名)：给int类型起了别名叫myInt类型
	type myInt int

	var num1 myInt = 30
	fmt.Println("num1", num1)

	var num2 int = 30
	num2 = int(num1) //虽然是别名，但是在go中遍历识别的时候还是认为myInt和int不是一种数据类型
	fmt.Println("num2", num2)

	test03(10, 3.14, a)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

为了简化数据类型定义，Go支持自定义数据类型 基本语法：Type 自定义数据类型名 数据类型

例如：type myInt int —> 这时myInt就等价int来使用了
例如：type mySum func(int, int) int ----> 这时mySum就等价于一个函数类型func(int, int) int

支持对函数返回值命名

//传统写法要求：返回值和返回值的类型对应，顺序不能差
func test04(num1 int, num2 int) (int, int) {
	result01 := num1 + num2
	result02 := num1 - num2
	return result01, result02
}

//升级写法：对函数返回值命名，里面顺序就无所谓了，顺序不用对应
func test05(num1 int, num2 int) (sum int, sub int) {
	sum = num1 + num2
	sub = num1 - num2
	return
}
1
2
3
4
5
6
7
8
9
10
11
12
13