函数
函数的引入提高了代码的复用性和维护性，可以减少代码的冗余。
函数的定义
完成某一特定功能的代码片段
函数定义格式
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)
}
函数之间为并列关系
基本语法
函数名
遵循标识符命名规范：名称含义，驼峰命名首字母不能是数字首字母大写该函数可以被本包文件和其它包文件使用（类似public）首学母小写只能被本包文件使用，其它包文件不能使用(类似private)
形式参数列表：可以是0个，接收外来数据（实参）返回值（类型）列表
可以是0个——无列表如果返回值只有一个，那么这个列表中类型左右的（）可以省略不写
Golang中函数不支持重载：函数名相同、形参列表不同Golang中支持可变参数（数量）（(如果你希望函数带有可变数量的参数）
//定义一个函数，函数的参数为：可变参数。。•参数的数量可变
//args..int 可以传入任意多个数量的int类型的数据 传入日个，1个，， n
func test (args...int){
//函数内部处理可变参数的时候，将可变参数当做切片来处理
}
基本数据头型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来值。以值传递方式的数据类型，如果希望在函数内的变量能修改函数外的变量，可以传入变量的地址＆，函数内以指针的方式操作变量。从效果来看类似引用传递。
内存分析
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(形参类型表)变量函数连量具体数据具体函数名
为了简化数据类型定义,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
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
}
相关文章
您阅读本篇文章共花了：
发表评论