Go的函数

一、函数的定义

函数要定义在main函数的外面，无所谓前后。

1、函数的基本格式

// 不带返回值的函数

func关键字 函数名(参数1 类型，参数2 类型，...){

	函数体内容代码

}

// 带一个返回值的函数

func关键字 函数名(参数1 类型，参数2 类型) 返回值类型 {

	函数体内容代码

}

// 带多个返回值的函数

func关键字 函数名(参数1 类型，参数2 类型) (返回值类型1，返回值类型2...) {

	函数体内容代码

}

func main() {

	test(66)

}

func test(a int) {

	fmt.Println(a)

}

func t3(a,b int) int {

	return a+b

}

2、函数的参数

Go中函数的参数只有位置参数一种，没有关键字参数。

如果有参数的类型相同，可以省略多余的类型关键字。

func关键字 函数名(参数1，参数2 类型，。。。){

	函数体内容代码

}

func main() {

    test(66,88)

    t2(1,2,"ok")

}

func test(a ,b int) {  // a,b都是int

	fmt.Println(a+b)

}  // 154

func t2(a,b int,c string)  {  // a,b是int，c是string

	fmt.Println(a+b,c)

}  // 3 ok

2.1 函数传参的特点：copy传值

go语言中函数传参，都是copy传递。不管是值类型还是引用类型。都会copy一份，传进这个函数。

如果是值类型的变量，传进函数后被修改，则不会影响被copy的变量。因为已经是不同的变量了。

但如果是引用类型的变量，传进函数后被修改，是会影响到其他的引用这个地址的变量的。因为直接将这个地址的值修改了。

Python的不同之处：

Python参数传递统一使用的是引用传递方式。

但Python对象分为可变对象(list,dict,set等)和不可变对象(number,string,tuple等)。

当传递的参数是可变对象的引用时，因为可变对象的值可以修改，因此可以通过修改参数值而修改原对象。

当传递的参数是不可变对象的引用时，虽然传递的是引用，参数变量和原变量都指向同一内存地址，但是由于Python做了处理使不可变对象无法修改，所以参数的修改不会影响原对象，而是重新开辟了一块地址放这个值。

3、函数的返回值

需要指定返回值类型是什么。

声明位置在参数与函数代码块之间。

如果有多个返回值，需要用小括号将返回值类型包起来。

而且返回几个值，就必须用几个值来接收。不像Python可以用一个变量来接收多个返回值。

如果不想接收参数，可以用下划线顶替。但在go中，下划线真的就是不接收，不像Python，下划线也是一个变量。

func main() {

	var r3 int = t3(1,2)

	fmt.Println(r3)

    var r4,r5 int= t4(2,1)

	fmt.Println(r4,r5)

}

func t3(a,b int) int {

	return a+b

}  // 3

func t4(a,b int) (int,int) {

	return a+b,a-b

}  // 3 1

4、可变长参数

...可以用来接收任意长度的参数。相当于Python中的*。

func main() {

	t5(1,2,3,4,5,6,7)

}

func t5(a ...int)  {

	fmt.Println(a)

}  // [1 2 3 4 5 6 7] 生成一个切片

二、函数的类型

函数的类型包含函数的参数，返回值。

var a func()

var b func(a,b int)

var c func(a,b int)int

var d func(a,b int)(int,string)

1、给函数的类型重命名

语法：type 类型名称函数类型

也可以给其他类型重命名。

func main() {

	var s Myfunc = t8(1,2)

	s(2)

}

type Myfunc  func(a int)int

// func test(x,y int) func(z int)int {

func t8(x,y int) Myfunc {

	//只是一个内层函数

	a:= func(z int)int {

		fmt.Println(x+y+z)

		return x+y+z

	}

	return a

}  

>>>:5

三、匿名函数

1、匿名函数的定义

GO中，匿名函数只能定义在函数的内部。

func t6()  {

	func () {  // 匿名函数

		fmt.Println("ok")

	}()

}

2、匿名函数的执行

// 方法一、直接加括号执行

func main() {

	t6()

}

func t6()  {

	func () {

		fmt.Println("ok")

	}()

}  // ok 

// 方法二、用变量接收

var a = func(a int) {

    fmt.Println("匿名函数")

}

fmt.Printf("%T",a) // func(int)

a(1)

四、闭包函数

1、闭包的概念

定义在函数内部
对外部作用域有引用(引用外部变量)

2、闭包函数的定义

/* 这就不是闭包，因为没有引用外部变量

func test() func() {

	//只是一个内层函数

	a:= func() {

		fmt.Printf("我是内层函数")

	}

	return a

}

*/

// 闭包函数：引用了外部的变量

func main() {

    var s Myfunc = t8(1,2)

    s(2)  // 5

}

type Myfunc  func(a int)int

// func test(x,y int) func(z int)int {

func t8(x,y int) Myfunc {

	a:= func(z int)int {

		fmt.Println(x+y+z)

		return x+y+z

	}

	return a

}

巴特西

Go的函数

Go的函数

一、函数的定义

1、函数的基本格式

2、函数的参数

2.1 函数传参的特点：copy传值

3、函数的返回值

4、可变长参数

二、函数的类型

1、给函数的类型重命名

三、匿名函数

1、匿名函数的定义

2、匿名函数的执行

四、闭包函数

1、闭包的概念

2、闭包函数的定义

最新文章

热门文章