与其它主要变成语言的差异
- 可以有多个返回值
- 所有参数都是值传递：slice，map，channel 会有传引用的错觉(比如切片,他背后对应的是一个数组,切片本身是一个数据结构,在这个数据结构中包含了指向了这个数组的指针,所以说,即便是在传值的情况下这个结构被复制到函数里了,在通过指针去操作这个数组的值的时候,其实是操作的是同一块空间,实际上是结构被复制了,但是结构里包含的指针指向的是同一个数组,所以才有这个错觉)
所有的参数都是值传递:在go中的函数是把值拷贝了一份,在函数里操作并不会改变外面的值,用指针接受参数是把指针地址拷贝了一份,他
- 所有参数都是值传递：slice，map，channel 会有传引用的错觉(比如切片,他背后对应的是一个数组,切片本身是一个数据结构,在这个数据结构中包含了指向了这个数组的指针,所以说,即便是在传值的情况下这个结构被复制到函数里了,在通过指针去操作这个数组的值的时候,其实是操作的是同一块空间,实际上是结构被复制了,但是结构里包含的指针指向的是同一个数组,所以才有这个错觉)
- 函数可以作为变量的值
- 函数可以作为参数和返回值
- 不支持重载,一个包不能有两个名字一样的函数
- 匿名函数
- 函数是一等公民: 参数, 变量, 返回值都可以是函数
值传递
把值拷贝了一份,优点不会改变外面的值
指针传递
拷贝了a的地址,函数内部很外部都是只想a,内部改变a,外部的值都会被改变
cache传递
cache拷贝了一份过去,只是把cache的指针拷贝了一份,当需要更改状态的时候需要用到指针传递
申明函数：
func 函数名(参数或多个参数 参数类型)(多个返回值的类型){}
func 函数名()单个返回值的类型{}
func 函数名(参数 ...参数类型)返回值类型{}
func(){}() 匿名函数
func a(){} // 无参数,无返回值
func add(a,b int){} // 多参数,无返回值,两个同样类型的参数可以省略写一个
func add(a int,b int) {}
func add(a,b int) int {} //多参数,返回一个 int 型值
func add(a,b int) (int,int){} //多参数,返回多个 int 型值
func add(a ...int) int {} // 可变参数,返回一个 int 型值
func () {}() // 匿名函数
可变参数函数例子
可变长参数会被转化成一个数组，然后通过数组遍历来完成
package main
import (
"testing"
"fmt"
)
func add(a ...int) int{
num:=0
for _,res:=a{
num+=res
}
return num
}
func TestNum(t *testing.T){
num:=add(1,2,3,4,5,6)
fmt.Println(num)
}
输出结果
21
用切片
package main
func add(a [8]int){ // 对值进行了拷贝,并不会改变S的值
a[1]=200
fmt.Println(a)
}
func sliceadd(a []int){ // 对
a[0]=100
fmt.Println(a)
}
func main(){
s:=[...]int{0,1,2,3,4,5,6,7}
add(s)
fmt.Println(s)
sliceadd(s[:])
fmt.Println(s)
}
结果
0,200,3,4,5,6,7
0,1,2,3,4,5,6,7
100,1,2,3,4,5,6,7
100,1,2,3,4,5,6,7
defer 函数
延迟执行函数
defer 在函数执行完之后 return 前才执行
通常用于清理某些资源和处理某些异常
在一个函数中,如果有多个 defer 那它的执行顺序是从后往前执行
package main
import (
"testing"
"fmt"
)
func add(a ...int) int{
num:=0
for _,res:=a{
num+=res
}
return num
}
func Clear(){
fmt.Println("你好吗?")
}
func TestNum(t *testing.T){
defer Clear()
num:=add(1,2,3,4,5,6)
fmt.Println(num)
}
运行结果
21
你好吗?
函数中有多个 defer 的例子
func calc(index string, a, b int) int {
ret := a + b
fmt.Println(index, a, b, ret)
return ret
}
func TestFn(t *testing.T) {
a := 1
b := 2
defer calc("1", a, b)
a = 0
defer calc("2", a, b)
b = 1
}
运行结果
2 0 2 2
1 1 2 3
这是一道面试题
func calc(index string, a, b int) int {
ret := a + b
fmt.Println(index, a, b, ret)
return ret
}
func TestFn(t *testing.T) {
a := 1
b := 2
defer calc("1", a, calc("10", a, b))
a = 0
defer calc("2", a, calc("20", a, b))
b = 1
}
运行结果
10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4
panic 程序异常中断,在go里面代表了不可修复的错误,在go中defer在panic之后也是会执行的，在内存中，如果程序遇到错误调用panic，那么它在执行panic前会把内存中程序信息全部清理完
匿名函数
// 第一种
func main(){
func(){
fmt.Println("你好")
}()
}
// 第二种 把匿名函数赋值给变量,然后执行变量
var f = func(){fmt.Println("你好")}
func main(){
f()
}
// 第三种 把匿名函数赋值给变量,然后执行变量
func main(){
f:=func(){fmt.Println("你好")}
f()
}
// 带参数的匿名函数
func main(){
func(str){
fmt.Println(str)
}("你好")
}
运行结果
你好
闭包函数
func timeSpent(inner func (op int) int) func (op int) int{
return func(n int) int {
start := time.Now()
ret := inner(n)
fmt.Println("time spent:", time.Since(start).Seconds())
return ret
}
}
timeSpent在这个闭包函数中传入的是一个函数 inner func(op int) int 相当于inner 的类型是func(opt int) int
package main
import "fmt"
func adder() func (int) int{
sum:=0 // 自由变量
return func(v int)int{ // v 是局部变量 这个匿名函数就是一个函数体
sum+=v
return sum
}
}
func main(){
a := adder()
for i :=0;i<10;i++{
fmt.Println(a(i))
}
}
adder 函数返回的时候返回的是个闭包
return func 返回的不是代码,返回是函数以及它的对sum的引用,sum会保存下来,保存到这个函数里面,
闭包函数实例
例子1:斐波那契数列
package main
import "fmt"
func fibonacci() func() int{
a,b :=0,1
return func() int{
a,b = b,a+b
return a
}
}
func main(){
f:=fibonacci()
for i:=0;i<10;i++{
fmt.Println(f())
}
}
结果
1
1
2
3
5
8
13
21
34
55
例子二: 为函数实现接口
func fibonacci() intGen {
a, b := 0, 1
return func() int {
a, b = b, a+b
return a
}
}
type intGen func() int
func (g intGen) Read(p []byte) (n int, err error) {
next := g()
if next > 100000 {
return 0, io.EOF
}
s := fmt.Sprintf("%d\n", next)
return strings.NewReader(s).Read(p)
}
func printFileContents(reader io.Reader) {
scanner := bufio.NewScanner(reader)
for scanner.Scan() {
fmt.Println(scanner.Text())
}
}
func main() {
f := fibonacci()
printFileContents(f)
}
