Golang学习记录5——函数1（函数引入）

函数

函数的引入提高了代码的复用性和维护性，可以减少代码的冗余。

函数的定义

完成某一特定功能的代码片段

• 函数定义格式

func 函数名（形参列表——变量 类型，···）（返回值列表——类型，···）{//如果返回值类型就一个的话，那么（）可以不用写
	执行语句
	return + 返回值列表
}

PS:返回值列表只需要定义变量类型

• 函数的定义和使用

package main
import (
	"fmt"
)

func sum1(num1 int, num2 int) (int)  {
	var sum int
	sum += num1
	sum += num2

	return sum
	
}

func main()  {
	
	sum := sum1(1,4)
	fmt.Println("和为",sum)
}

• 函数之间为并列关系

基本语法

1. 函数名

• 遵循标识符命名规范：名称含义，驼峰命名
• 首字母不能是数字
• 首字母大写该函数可以被本包文件和其它包文件使用（类似public）
• 首学母小写只能被本包文件使用，其它包文件不能使用(类似private)

2. 形式参数列表：可以是0个，接收外来数据（实参）
3. 返回值（类型）列表

• 可以是0个——无列表
• 如果返回值只有一个，那么这个列表中类型左右的（）可以省略不写

4. Golang中函数不支持重载：函数名相同、形参列表不同
5. Golang中支持可变参数（数量）（(如果你希望函数带有可变数量的参数）

//定义一个函数，函数的参数为：可变参数。。•参数的数量可变
//args..int 可以传入任意多个数量的int类型的数据 传入日个，1个，， n
func test (args...int){
	//函数内部处理可变参数的时候，将可变参数当做切片来处理
}

6. 基本数据头型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来值。
7. 以值传递方式的数据类型，如果希望在函数内的变量能修改函数外的变量，可以传入变量的地址＆，函数内以指针的方式操作变量。从效果来看类似引用传递。

内存分析

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

func main0{
	//调用函数：交换10和20
	var numl int = 10
	var num2 int = 20
	fmt.Printf（"交换前的两个数：numl =号, num2 = 号v In" , num1,num2)
	exchangeNum (num1, num2)
	fmt.Printf("交换后的两个数： numl = gv,num2 = su \n"',numl,num2)
}

8. GOlang中函数也是一种数据类型，可以当做变量类型给变量进行声明，则所声明的变量就变成了函数类型变量，使用该变量就能直接对函数进行调用。

• 使用的时候这种数据类型的时候用法和基本数据类型类似：变量类型——func(参数列表) (返回值列表)，变量值——函数名,变量使用——变量（参数）

//自定义函数
func print()  {
	fmt.Println("你调用了函数！")
}

func main(){

	//定义的时候只需要加所定义函数的名称，而说明类型的时候要按照函数名+参数列表（类型）进行定义，eg：func（int）
	var f1 func() = print   //定义方式1
	f2 := print      //定义方式2
	fmt.Printf("f1所定义的变量类型为：%T\n",f1)
	fmt.Printf("f2所定义的变量类型为：%T\n",f2)
	f1()
	f2()
}

f1所定义的变量类型为：func()
f2所定义的变量类型为：func()
你调用了函数！
你调用了函数！

//自定义函数
func print(a int) (int) {
	fmt.Println("你调用了函数！")
	return a
}

func main(){

	//定义的时候只需要加所定义函数的名称，而说明类型的时候要按照函数名+参数列表（类型）进行定义，eg：func（int）
	var f1 func(int) int = print   //定义方式

	fmt.Printf("f1所定义的变量类型为：%T\n",f1)
	fmt.Printf("f1（10）所返回的值为：%d\n",f1(10)) 
	f1(20)    //仅仅只是调用了，但没有接受返回的值
}

f1所定义的变量类型为：func(int) int
你调用了函数！
f1（10）所返回的值为：10
你调用了函数！

PS：函数可以只调用，但不接受返回的值
9. 函数为一种数据类型，那么函数就能像变量一样，所谓形参，并调用。

//自定义函数
func print()  {
	fmt.Println("你调用了函数！")
}

//自定义函数（函数形参）
func printa(function func())  {

	fmt.Println("本函数使用print函数作为形参，下面将会调用：")
	function()
	
}

func main(){

	var f1 func(func()) = printa
	var f2 func() = print

	fmt.Printf("f1所定义的变量类型为：%T\n",f1)
	fmt.Printf("f2所定义的变量类型为：%T\n",f2)

	f1(f2)  //此处传入的是变量而不能写成f1(f2（）)，因为f2()不是函数变量的值或者变量，变量——f2;值——函数print
	
}

f1所定义的变量类型为：func(func())
f2所定义的变量类型为：func()
本函数使用print函数作为形参，下面将会调用：
你调用了函数！

PS：函数当作参数传入时，传入的不是函数的返回值，函数的返回值可能不是函数类型，所以传入的是函数类型的变量，这和传入基本数据类型的具体值一样，不能混淆
总的一点：清楚一下对应关系

基本数据类型	函数数据类型
数据类型（int、float···）	func(形参类型表)
变量	函数连量
具体数据	具体函数名

10. 为了简化数据类型定义,Go支持自寇义数据类型

• 基本语法：type 自定义数据类型名 数据类型
  例如:type mylnt int——这时mylnt就等价int来使用了．
  例如:type myfunc func(int)——这时myfun就等价func(int)来使用了．更加简便
  PS：虽然是重命名的类型，当不能相互直接使用，并不是等价——编译的时候类型就为重命名之后的类型

func main(){

	type myint int
	var a1 myint
	fmt.Printf("a1的类型为%T\n",a1)	
}

a1的类型为main.myint        //函数.重命名数据类型

错误使用

func main(){

	type myint int
	var a1 myint
	var a2 int = 9
	a1 = a2     // 报错：cannot use a2 (variable of type int) as myint value in assignment
	fmt.Printf("a1的类型为%T\n",a1)	
	fmt.Printf("a1的类型为%T\n",a2)	

}

所以只能进行强制转换

func main(){

	type myint int
	var a1 myint
	var a2 int = 9
	a1 = myint(a2)    //强制转换
	fmt.Printf("a1的类型为%T\n",a1)	
	fmt.Printf("a2的类型为%T\n",a2)	
	fmt.Printf("a1的类型为%d\n",a1)	 //但此处格式化输出的格式还是为10进制数

}

a1的类型为main.myint
a2的类型为int
a1的类型为9        

11. golang支持对返回值命名

• 传统写法：返回值和返回值类型对应

func print(a int) ( int float) {
	fmt.Println("你调用了函数！")
	a  := 1
	b := 1.2
	return a,b
}

• 升级写法：返回值命名，return后不用写变量了，且顺序无所谓

func print(a int) (a int,b float) {
	fmt.Println("你调用了函数！")
	a  := 1
	b := 1.2
	return 
}