Go函数,
写法:声明函数:func 函数名(参数列表)[(返回值列表)]{}
特点:
不支持重载，一个包不能有两个名字一样的函数
函数是一等公民,函数也是一种类型,一个函数可以赋值给变量
匿名函数
多返回值
函数传递方式:
值类型
引用类型
map、 slice、 chan、指针、 interface默认以引用的方式传递
无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷呗，一般来说，地址拷呗更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。
测试一:函数赋值
func add (a int,b int) int {
return a + b
}
func main() {
c:=add
fmt.Printf("%P %T %p %T \n",c,add,c,add)
sum :=add(30,40)
fmt.Println(sum)
ccc :=c(30,40)
fmt.Println(ccc)
}
一:自定义函数:
type add_func func(int ,int)int
//自定义一个函数类型,也可以传递
func operator(op add_func,a ,b int) int {
//值传递给自定义函数
return op(a,b)
}
func main(){
sum :=operator(c,100,200)
fmt.Println(sum)
}
测试二:返回值写法
func test2(a,b int)(c int) {
c = a +b
//不必写c,默认会把c返回
return
}
func test3(a,b int)(sum int,avg int) {
sum = a +b
avg = (a +b)/2
return
}
func main(){
e,q:=test3(6,7)
fmt.Println(d,e,q)
}
二:可变参数: (这里又有...用法)
func add(arg…int) int {
}
0个或多个参数
func add(a int, arg…int) int {
}
1个或多个参数
func add(a int, b int, arg…int) int {
}
2个或多个参数
其中arg是一个slice，我们可以通过arg[index]依次访问所有参数通过len(arg)来判断传递参数的个数
测试三:多个值传递
func test4(arg...int) int {
var sum int
fmt.Println("test4---arg",arg)
for i:=0;i<len(arg);i++{
sum = sum + arg[i]
}
return sum
}
func testArg() {
fmt.Println(test4(1))
fmt.Println(test4())
fmt.Println(test4(1,3,4,5,6,2121,21,12,))
}
func main(){
testArg()
}
三:关键字defer
当函数返回时,执行defer语句,因此,可以用来做资源清理 例如:
关闭文件句柄
锁资源释放
数据库连接释放
多个defer语句,按先进后出的方式执行,
defer语句中的变量,在defer声明时就决定了
示例1:
func test5() {
i:=0
defer fmt.Println("test5",i)
i++
return
}
>>>test5 0
示例二:
func test6() {
for i:=0;i<5;i++{
defer fmt.Println("test6",i)
}
}
>>
test6 4
test6 3
test6 2
test6 1
test6 0
四:函数递归
func test7(a int) int {
if a == 1{
return 1
}
return test7(a-1) * a
}
n:=test7(5)
fmt.Println(n)
五:斐波那契
func test8( a int) int {
if a <= 1{
return 1
}
return test8(a -1) + test8(a - 2)
}
for i:=0;i<20;i++{
n:=test8(i)
fmt.Printf("%d ",n)
}
六:闭包：
func test9() func(int) int {
var x int
fmt.Println("---XXX",x)
//返回一个匿名函数
return func(a int) int {
//x就是闭包里面的全局变量
//因为全局变量生命周期长
//调用的结果存在x里面,所以下次调用的时候,是在之前结果基础上在相加、
//观察哪个是外部变量, 这个外部变量就是成员变量！，值一直会在, 这里x就是外部变量
fmt.Println("---funcXXX",x)
x+=a
return x
}
}
func main(){
var f = test9()
fmt.Println(f(1),"-")
fmt.Println(f(20),"-")
fmt.Println(f(300),"-")
}
》》
---XXX 0
---funcXXX 0
1 -
---funcXXX 1
21 -
---funcXXX 21
321 -
例子二:
func test10(suffix string) func(string) string {
//suffix 可以当成 成员变量, 一直存在
f:= func(name string) string {
if !strings.HasSuffix(name,suffix){
return name + suffix
}
return name
}
return f
}
func main(){
func1 :=test10(".bmp")
func2 :=test10(".jgp")
fmt.Println(func1("zcq"))
fmt.Println(func2("rch"))
}
©著作权归作者所有：来自51CTO博客作者zhaichaoqun的原创作品，如需转载，请与作者联系，否则将追究法律责任
共同学习，写下你的评论
评论加载中...
作者其他优质文章
