go语言学习笔记之四---函数的使用

一格式定义

函数构成代码执行的逻辑结构。在Go语言中，函数的基本组成为：关键字func、函数名、参数列表、返回值、函数体和返回语句。

Go 语言函数定义格式如下：

func FuncName(/*参数列表*/) (o1 type1, o2 type2/*返回类型*/) {
    //函数体

    return v1, v2 //返回多个值
}

函数定义说明：

func：函数由关键字 func 开始声明
FuncName：函数名称，根据约定，函数名首字母小写即为private，大写即为public
参数列表：函数可以有0个或多个参数，参数格式为：变量名类型，如果有多个参数通过逗号分隔，不支持默认参数
返回类型：

①　上面返回值声明了两个变量名o1和o2(命名返回参数)，这个不是必须，可以只有类型没有变量名

②　如果只有一个返回值且不声明返回值变量，那么你可以省略，包括返回值的括号

③　如果没有返回值，那么就直接省略最后的返回信息

④　如果有返回值，那么必须在函数的内部添加return语句

二自定义函数

2.1 无参无返回值

package main

import "fmt"

func main() {

	Test() //无参无返回值函数调用

}

func Test() { //无参无返回值函数定义

	fmt.Println("this is a test func")

}

2.2 有参无返回值

2.2.1 普通参数列表

package main

import "fmt"

func main() {

	Test01(10, 20) //函数调用

	Test02(11, 22) //函数调用

}

func Test01(v1 int, v2 int) { //方式1

	fmt.Printf("v1 = %d, v2 = %d\n", v1, v2)

}

func Test02(v1, v2 int) { //方式2, v1, v2都是int类型

	fmt.Printf("v1 = %d, v2 = %d\n", v1, v2)

}

2.2.2 不定参数列表

1) 不定参数类型

不定参数是指函数传入的参数个数为不定数量。为了做到这点，首先需要将函数定义为接受不定参数类型：

//形如...type格式的类型只能作为函数的参数类型存在，并且必须是最后一个参数

package main

import "fmt"

func main() {

	//函数调用，可传0到多个参数

	Test()

	Test(1)

	Test(1, 2, 3, 4)

}

func Test(args ...int) {

	for _, n := range args { //遍历参数列表

		fmt.Println(n)

	}

}

2) 不定参数的传递

package main

import "fmt"

func main() {
	Test(1, 2, 3) //函数调用

}
func MyFunc01(args ...int) {

	fmt.Println("MyFunc01")

	for _, n := range args { //遍历参数列表
		fmt.Println(n)

	}

}

func MyFunc02(args ...int) {

	fmt.Println("MyFunc02")

	for _, n := range args { //遍历参数列表
		fmt.Println(n)
	}

}

func Test(args ...int) {

	MyFunc01(args...)     //按原样传递, Test()的参数原封不动传递给MyFunc01
	MyFunc02(args[1:]...) //Test()参数列表中，第1个参数及以后的参数传递给MyFunc02

}

2.3 无参有返回值

有返回值的函数，必须有明确的终止语句，否则会引发编译错误。

2.3.1 一个返回值

package main

import "fmt"

func main() {

	v1 := Test01() //函数调用

	v2 := Test02() //函数调用

	v3 := Test03() //函数调用

	fmt.Printf("v1 = %d, v2 = %d, v3 = %d\n", v1, v2, v3)

}

func Test01() int { //方式1

	return 250

}

//官方建议：最好命名返回值，因为不命名返回值，虽然使得代码更加简洁了，但是会造成生成的文档可读性差
func Test02() (value int) { //方式2, 给返回值命名

	value = 250

	return value

}

func Test03() (value int) { //方式3, 给返回值命名

	value = 250

	return

}

2.3.2 多个返回值

package main

import "fmt"

func main() {

	v1, v2 := Test01() //函数调用

	_, v3 := Test02() //函数调用， 第一个返回值丢弃

	v4, _ := Test02() //函数调用， 第二个返回值丢弃

	fmt.Printf("v1 = %d, v2 = %s, v3 = %s, v4 = %d\n", v1, v2, v3, v4)

}

func Test01() (int, string) { //方式1

	return 250, "sb"

}

func Test02() (a int, str string) { //方式2, 给返回值命名

	a = 250

	str = "sb"

	return

}

2.4 有参有返回值

package main

import "fmt"

func main() {

	min, max := MinAndMax(33, 22)

	fmt.Printf("min = %d, max = %d\n", min, max) //min = 22, max = 33

}

//求2个数的最小值和最大值
func MinAndMax(num1 int, num2 int) (min int, max int) {
	if num1 > num2 { //如果num1 大于 num2
		min = num2
		max = num1
	} else {
		max = num2
		min = num1
	}
	return
}

三递归函数

递归指函数可以直接或间接的调用自身。

递归函数通常有相同的结构：一个跳出条件和一个递归体。所谓跳出条件就是根据传入的参数判断是否需要停止递归，而递归体则是函数自身所做的一些处理。

package main

import "fmt"

func main() {
	fmt.Println(Test01())    //5050
	fmt.Println(Test02(100)) //5050
	fmt.Println(Test03(1))   //5050
}

//通过循环实现1+2+3……+100
func Test01() int {
	i := 1

	sum := 0
	for i = 1; i <= 100; i++ {
		sum += i
	}
	return sum

}

//通过递归实现1+2+3……+100

func Test02(num int) int {
	if num == 1 {
		return 1
	}
	return num + Test02(num-1) //函数调用本身

}

//通过递归实现1+2+3……+100
func Test03(num int) int {
	if num == 100 {
		return 100
	}
	return num + Test03(num+1) //函数调用本身
}

四函数类型 (回调函数)

在Go语言中，函数也是一种数据类型，我们可以通过type来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型。

package main

import "fmt"

func main() {

	//函数调用，第三个参数为函数名字，此函数的参数，返回值必须和FuncType类型一致
	result := Calc(1, 1, Add)
	fmt.Println(result) //2

	var f FuncType = Minus
	fmt.Println("result = ", f(10, 2)) //result = 8

}

type FuncType func(int, int) int //声明一个函数类型, func后面没有函数名

//函数中有一个参数类型为函数类型：f FuncType

func Calc(a, b int, f FuncType) (result int) {

	result = f(a, b) //通过调用f()实现任务

	return

}

func Add(a, b int) int {

	return a + b

}

func Minus(a, b int) int {

	return a - b

}

第二个示例函数作为实参

函数作为参数传递，实现回调。

package main

import (
	"fmt"
)

// 声明一个函数类型
type cb func(int) int

func main() {
	testCallBack(1, callBack)
	testCallBack(2, func(x int) int {
		fmt.Printf("我是回调2，x：%d\n", x)
		return x
	})
}

func testCallBack(x int, f cb) {
	f(x)
}

func callBack(x int) int {
	fmt.Printf("我是回调1，x：%d\n", x)
	return x
}

运行结果为

C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
我是回调1，x：1
我是回调2，x：2
成功: 进程退出代码 0.

五匿名函数与闭包

所谓闭包就是一个函数“捕获”了和它在同一作用域的其它常量和变量。这就意味着当闭包被调用的时候，不管在程序什么地方调用，闭包能够使用这些常量或者变量。它不关心这些捕获了的变量和常量是否已经超出了作用域，所以只有闭包还在使用它，这些变量就还会存在。

在Go语言里，所有的匿名函数(Go语言规范中称之为函数字面量)都是闭包。匿名函数是指不需要定义函数名的一种函数实现方式，它并不是一个新概念，最早可以回溯到1958年的Lisp语言。

5.1 基本使用

package main

import "fmt"

func main() {

	i := 0

	str := "mike"

	//方式1

	f1 := func() { //匿名函数，无参无返回值

		//引用到函数外的变量

		fmt.Printf("方式1：i = %d, str = %s\n", i, str)

	}

	f1() //函数调用

	//方式1的另一种方式

	type FuncType func() //声明函数类型, 无参无返回值

	var f2 FuncType = f1

	f2() //函数调用

	//方式2

	var f3 FuncType = func() {

		fmt.Printf("方式2：i = %d, str = %s\n", i, str)

	}

	f3() //函数调用

	//方式3

	func() { //匿名函数，无参无返回值

		fmt.Printf("方式3：i = %d, str = %s\n", i, str)

	}() //别忘了后面的(), ()的作用是，此处直接调用此匿名函数

	//方式4, 匿名函数，有参有返回值

	v := func(a, b int) (result int) {

		result = a + b

		return

	}(1, 1) //别忘了后面的(1, 1), (1, 1)的作用是，此处直接调用此匿名函数， 并传参

	fmt.Println("v = ", v)

}

5.2 闭包捕获外部变量

package main

import "fmt"

func main() {

	i := 10

	str := "mike"

	func() {

		i = 100

		str = "go"

		//内部：i = 100, str = go

		fmt.Printf("内部：i = %d, str = %s\n", i, str)

	}() //别忘了后面的(), ()的作用是，此处直接调用此匿名函数

	//外部：i = 100, str = go

	fmt.Printf("外部：i = %d, str = %s\n", i, str)

}

5.3 函数返回值为匿名函数

package main

import "fmt"

// squares返回一个匿名函数，func() int
// 该匿名函数每次被调用时都会返回下一个数的平方。
func squares() func() int {

	var x int

	return func() int { //匿名函数

		x++ //捕获外部变量
		return x * x

	}

}

func main() {

	f := squares()

	fmt.Println(f()) // "1"

	fmt.Println(f()) // "4"
	fmt.Println(f()) // "9"

	fmt.Println(f()) // "16"

}

函数squares返回另一个类型为 func() int 的函数。对squares的一次调用会生成一个局部变量x并返回一个匿名函数。每次调用时匿名函数时，该函数都会先使x的值加1，再返回x的平方。第二次调用squares时，会生成第二个x变量，并返回一个新的匿名函数。新匿名函数操作的是第二个x变量。

通过这个例子，我们看到变量的生命周期不由它的作用域决定：squares返回后，变量x仍然隐式的存在于f中。

六延迟调用defer

6.1 defer作用

关键字 defer ⽤于延迟一个函数或者方法（或者当前所创建的匿名函数）的执行。注意，defer语句只能出现在函数或方法的内部。

package main

import "fmt"

func main() {

	fmt.Println("this is a test")

	defer fmt.Println("this is a defer") //main结束前调用

}

运行结果为

this is a test
this is a defer

defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁。通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放。释放资源的defer应该直接跟在请求资源的语句后。

6.2 多个defer执行顺序

如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。哪怕函数或某个延迟调用发生错误，这些调用依旧会被执⾏。

package main

import "fmt"

func main() {

	defer fmt.Println("aaaaaaaa")

	defer fmt.Println("bbbbbbbb")

	defer test(0)

	defer fmt.Println("cccccccc")

}

func test(x int) {

	fmt.Println(100 / x) //x为0时，产生异常

}

运行结果为

C:/Go/bin/go.exe build [C:/Users/qingteng/Desktop/aa/src]
成功: 进程退出代码 0.
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
cccccccc
bbbbbbbb
aaaaaaaa
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.test(0x0)
	C:/Users/qingteng/Desktop/aa/src/main.go:19 +0xc5
main.main()
	C:/Users/qingteng/Desktop/aa/src/main.go:15 +0x198
错误: 进程退出代码 2.

6.3 defer和匿名函数结合使用


import "fmt"

func main() {

	a, b := 10, 20

	defer func(x int) { // a以值传递方式传给x

		fmt.Println("defer:", x, b) // b 闭包引用

	}(a)

	a += 10

	b += 100

	fmt.Printf("a = %d, b = %d\n", a, b)

}

运行结果为

C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
a = 20, b = 120
defer: 10 120
成功: 进程退出代码 0.

七获取命令行参数

package main

import (
	"fmt"

	"os" //os.Args所需的包
)

func main() {

	args := os.Args //获取用户输入的所有参数

	//如果用户没有输入,或参数个数不够,则调用该函数提示用户

	if args == nil || len(args) < 2 {

		fmt.Println("err: xxx ip port")

		return

	}

	ip := args[1] //获取输入的第一个参数

	port := args[2] //获取输入的第二个参数

	fmt.Printf("ip = %s, port = %s\n", ip, port)

}

运行结果为

C:\Users\qingteng\Desktop\aa\src
λ ls
main.go  src.exe*  sub/

C:\Users\qingteng\Desktop\aa\src
λ src 127.0.0.1 8080
ip = 127.0.0.1, port = 8080

八作用域

作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。

8.1 局部变量

在函数体内声明的变量、参数和返回值变量就是局部变量，它们的作用域只在函数体内：

可通过花括号来控制变量的作用域，花括号中的变量是单独的作用域，同名变量会覆盖外层

package main

import (
	"fmt"
)

func test(a, b int) {

	var c int

	a, b, c = 1, 2, 3

	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

}

func main() {

	//a, b, c = 1, 2, 3 //err, a, b, c不属于此作用域

	{

		var i int

		i = 10

		fmt.Printf("i = %d\n", i)

	}

	//i = 20 //err, i不属于此作用域

	if a := 3; a == 3 {
		fmt.Println("a = ", a)

	}

	//a = 4 //err，a只能if内部使用

}

8.2 全局变量

在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

package main

import (
	"fmt"
)

var a int //全局变量的声明

func test() {

	fmt.Printf("test a = %d\n", a)

}

func main() {

	a = 10

	fmt.Printf("main a = %d\n", a) //main a = 10

	test() //test a = 10

}

运行结果为

C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
main a = 10
test a = 10
成功: 进程退出代码 0.

8.3 不同作用域同名变量

在不同作用域可以声明同名的变量，其访问原则为：在同一个作用域内，就近原则访问最近的变量，如果此作用域没有此变量声明，则访问全局变量，如果全局变量也没有，则报错。

package main

import (
	"fmt"
)

var a int //全局变量的声明

func test01(a float32) {

	fmt.Printf("a type = %T\n", a) //a type = float32

}

func main() {

	fmt.Printf("a type = %T\n", a) //a type = int, 说明使用全局变量的a

	var a uint8 //局部变量声明

	{

		var a float64 //局部变量声明

		fmt.Printf("a type = %T\n", a) //a type = float64

	}

	fmt.Printf("a type = %T\n", a) //a type = uint8

	test01(3.14)

	test02()

}

func test02() {

	fmt.Printf("a type = %T\n", a) //a type = int

}

运行结果为

C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
a type = int
a type = float64
a type = uint8
a type = float32
a type = int
成功: 进程退出代码 0.

九函数参数传递

函数如果使用参数，该变量可称为函数的形参。

形参就像定义在函数体内的局部变量。

调用函数，可以通过两种方式来传递参数：

传递类型	描述
值传递	值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递	引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

9.1 值传递

传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

以下定义了 swap() 函数：

package main

import (
	"fmt"
)

/* 定义相互交换值的函数 */
func swap(x, y int) int {
	var temp int

	temp = x /* 保存 x 的值 */
	x = y    /* 将 y 值赋给 x */
	y = temp /* 将 temp 值赋给 y*/

	return temp
}

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200

	fmt.Printf("交换前 a 的值为 : %d\n", a)
	fmt.Printf("交换前 b 的值为 : %d\n", b)

	/* 通过调用函数来交换值 */
	swap(a, b)

	fmt.Printf("交换后 a 的值 : %d\n", a)
	fmt.Printf("交换后 b 的值 : %d\n", b)
}

运行结果为

C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
交换前 a 的值为 : 100
交换前 b 的值为 : 200
交换后 a 的值 : 100
交换后 b 的值 : 200
成功: 进程退出代码 0.

9.2 引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

引用传递指针参数传递到函数内，以下是交换函数 swap()使用了引用传递：

package main

import (
	"fmt"
)

/* 定义交换值函数*/
func swap(x *int, y *int) {
	var temp int
	temp = *x /* 保持 x 地址上的值 */
	*x = *y   /* 将 y 值赋给 x */
	*y = temp /* 将 temp 值赋给 y */
}

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200

	fmt.Printf("交换前，a 的值 : %d\n", a)
	fmt.Printf("交换前，b 的值 : %d\n", b)

	/* 调用 swap() 函数
	 * &a 指向 a 指针，a 变量的地址
	 * &b 指向 b 指针，b 变量的地址
	 */
	swap(&a, &b)

	fmt.Printf("交换后，a 的值 : %d\n", a)
	fmt.Printf("交换后，b 的值 : %d\n", b)
}

运行结果为

C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100
成功: 进程退出代码 0.

go语言学习笔记之四---函数的使用

用一生去回望，那些经年的岁月，是记忆里不灭的伤

一格式定义

二自定义函数

2.1 无参无返回值

2.2 有参无返回值

2.2.1 普通参数列表

2.2.2 不定参数列表

2.3 无参有返回值

2.3.1 一个返回值

2.3.2 多个返回值

2.4 有参有返回值

三递归函数

四函数类型 (回调函数)

五匿名函数与闭包

5.1 基本使用

5.2 闭包捕获外部变量

5.3 函数返回值为匿名函数

六延迟调用defer

6.1 defer作用

6.2 多个defer执行顺序

6.3 defer和匿名函数结合使用

七获取命令行参数

八作用域

8.1 局部变量

8.2 全局变量

8.3 不同作用域同名变量

九函数参数传递

9.1 值传递

9.2 引用传递

FEATURED TAGS

FRIENDS

一 格式定义

二 自定义函数

2.1 无参无返回值

2.2 有参无返回值

2.2.1 普通参数列表

2.2.2 不定参数列表

2.3 无参有返回值

2.3.1 一个返回值

2.3.2 多个返回值

2.4 有参有返回值

三 递归函数

四 函数类型 (回调函数)

五 匿名函数与闭包

5.1 基本使用

5.2 闭包捕获外部变量

5.3 函数返回值为匿名函数

六 延迟调用defer

6.1 defer作用

6.2 多个defer执行顺序

6.3 defer和匿名函数结合使用

七 获取命令行参数

八 作用域

8.1 局部变量

8.2 全局变量

8.3 不同作用域同名变量

九 函数参数传递

9.1 值传递

9.2 引用传递

FEATURED TAGS

FRIENDS

一格式定义

二自定义函数

三递归函数

四函数类型 (回调函数)

五匿名函数与闭包

六延迟调用defer

七获取命令行参数

八作用域

九函数参数传递