Go语言基础（三）函数

先写一个最基础的函数案例

import "fmt"

func main() {
	fmt.Println(max(5, 100))
}

func max(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

函数可能有以下几种情况

• 无参无返回值
• 有一个参数的函数
• 有两个 or 多个参数的函数
• 有一个返回值的函数
• 有两个 or 多个返回值的函数

package main

import "fmt"

func main() {
	printinfo()
	myprint("54564")
	myprint1("54564",5)
	
	fmt.Println(add2(55, 99))
	fmt.Println(swap(55, 99))
}

// 无参数无返回值的函数
func printinfo() {
	fmt.Println("dasda")
}

// 有一个参数的函数
func myprint(msg string) {
	fmt.Println(msg)
}

// 有两个参数的函数
func myprint1(msg string, a int) {
	fmt.Println(msg)
	fmt.Println(a)
}
// 有一个返回值的函数
func add2(a, b int) int {
	c := a + b
	return c
}

//有多个返回值的函数
func swap(a, b int) (int, int) {
	a, b = b, a
	return a, b
}

1、return 如果直接定义了，那么返回结果按照 return 的顺序
2、直接调用return不带结果，那么则返回 函数返回值定义的顺序进行结果返回。

package main

import "fmt"

//函数

func main() {
	//var v1 = 1
	//var v2 = 2
	//fmt.Println(add(v1, v2))
	fmt.Println(add(1, 2))
	fmt.Println(add1(2, 5))
}

func add(a, b int) (int, int) {
	c := a + b
	d := a - b
	return c, d
}

func add1(a, b int) (c, d int) {
	c = a + b
	d = a - b
	return
}

如果想在函数中传入可变数量的参数，应该怎么办呢？

package main

import "fmt"

func main() {
	fmt.Println(add(5, 6, 8, 5))
}

func add(a int, nums ...int) int {
	sum := 0
	sum += a
	for i := 0; i < len(nums); i++ {
		sum += nums[i]
	}
	return sum
}

值传递与引用传递

package main

import "fmt"

func main() {

	s1 := [4]int{1, 2, 3, 4}
	fmt.Println(s1)
	show1(s1)
	fmt.Println(s1)

	s2 := []int{1, 2, 3, 4}
	fmt.Println(s2)
	show2(s2)
	fmt.Println(s2)
}

func show1(a [4]int) {
	a[0] = 100
	fmt.Println(a)
}
func show2(a []int) {
	a[0] = 100
	fmt.Println(a)
}

[1 2 3 4]
[100 2 3 4]
[1 2 3 4]
[1 2 3 4]
[100 2 3 4]
[100 2 3 4]

函数传参总结

package main

import "fmt"

// go语言函数传参总结
func main() {
	var a int = 5
	var b int = 10
	var c int = 115
	var d = [3]int{0, 1, 6}
	e := [3]*int{&a, &b, &c}
	fmt.Println(f1(1, 2))
	fmt.Println(f2([3]int{1, 2, 30}))
	fmt.Println(f3([]int{11, 22, 222}))
	fmt.Println(f4(&a))
	fmt.Println(f5(e))
	fmt.Println(f6(&d))
	f7(1111, 1, 2, 3, 4, 5, 6, 7)
}

// 基本形式
func f1(a, b int) (int, int) {
	return b, a
}

// 传入数组
func f2(a [3]int) [3]int {
	return a
}

// 传入切片
func f3(a []int) []int {
	return a
}

// 传入指针
func f4(a *int) int {
	return *a
}

//传入指针数组

func f5(a [3]*int) [3]int {
	var b = [3]int{*a[0], *a[1], *a[2]}
	return b
}

//传入数组指针

func f6(a *[3]int) [3]int {
	return *a
}

//传入不定长数据
func f7(a int, num ...int) {
	fmt.Println(a)
	for _, v := range num {
		fmt.Println(v)
	}
	for i := 0; i < len(num); i++ {
		fmt.Println(num[i])
	}

}

2 1
[1 2 30]
[11 22 222]
5
[5 10 115]
[0 1 6]
1111
1
2
3
4
5
6
7
1
2
3
4
5
6
7

匿名函数
Go语言支持匿名函数，即在需要使用函数时再定义函数，匿名函数没有函数名只有函数体，函数可以作为一种类型被赋值给函数类型的变量，匿名函数也往往以变量方式传递。匿名函数是指不需要定义函数名的一种函数实现方式，由一个不带函数名的函数声明和函数体组成。

func (inputs) (outputs) {
   // function body
}(arguments)

基础案例

func(data int) {
    fmt.Println("hello", data)
}(100)

注意第3行}后的(100)，表示对匿名函数进行调用，传递参数为 100。

	// 匿名函数，在函数体后增加()，调用了这个函数，匿名函数只能一次。
	func() {
		fmt.Println("我是一个匿名函数")
	}()

	// 将匿名函数进行赋值，就可以实现多次调用。
	//注意这种匿名函数定义的时候最后不加括号调用
	f3 := func() {
		fmt.Println("我是一个匿名函数")
	}
	f3()

	// 匿名函数是否可以添加参数和返回值
	func(a, b int) {
		fmt.Println("a,b")
	}(1, 2)

	// 将匿名函数的返回值定义给变量。
	r1 := func(a, b int) int {
		fmt.Println("sdasdascdvdv")
		return a + b
	}(1, 2)
	fmt.Println(r1)

注意最后一块代码将会先调用匿名函数，所以会打印那一串字母

我是一个匿名函数
我是一个匿名函数
a,b
sdasdascdvdv
3

func main() {
	//f2 如果不加括号就是一个变量
	fmt.Printf("%T\n", f2)     //func(int, int)
	fmt.Printf("%T\n", "asda") //string
	fmt.Printf("%T\n", 5)      //int

	//var f5 func(int, int) int
	f5 := f2
	fmt.Println(f5)
	fmt.Println(f2)
	f5(1, 2)
}

func f2(a, b int) int {
	fmt.Println(a, b)
	return 1
}

func(int, int) int
string
int
0xc2fea0
0xc2fea0
1 2

匿名函数用作回调函数
遍历中访问每个元素的操作使用匿名函数来实现，用户传入不同的匿名函数体可以实现对元素不同的遍历操作

func main() {
	visite([]int{1, 2, 3, 4}, func(i int) {
		fmt.Println(i)
	})

}

func visite(a []int, f func(int)) {
	for _, v := range a {
		f(v)
	}
}

1
2
3
4