普通函数
- 定义 : func 函数名 {}
- 执行函数 : 函数名()
- 函数 类型
- 无参数函数
- 无返回值函数
- 有1个或者多个 参数 函数
- 有1个或者多个 返回值 函数
- 参数的传递
- 函数作用域
- 函数内部的定义的变量,只能作用到函数内部
- 全局变量,函数内也可以使用
go code
package main
import "fmt"
func test1() {
fmt.Println("执行test1")
}
func compareNum(num1 int, num2 int) int {
if num1 < num2 {
return num2
} else {
return num1
}
}
func exchangeString(x string, y string) (string, string) {
return y, x
}
func funcDefineReturn(x, y float64) (circumference float64, area float64) {
circumference = (x + y) * 2
area = x * y
return
}
func funcDefineReturnNotUse(x, y float64) (circumference float64, area float64) {
circumference = (x + y) * 2
area = x * y
return area, circumference
}
func funcNotDefineReturnUse(x, y float64) (float64, float64) {
circumference := (x + y) * 2
area := x * y
return circumference, area
}
func getSum(nums ...int) int {
fmt.Printf("%T\n", nums)
sum := 0
for i := 0; i < len(nums); i++ {
sum += nums[i]
}
return sum
}
func main() {
test1()
compareRes := compareNum(1, 2)
fmt.Println("compareNum func result: ", compareRes)
x := "hello"
y := "word"
fmt.Println("exchangeString func before: ", x, y)
exchangeResX, exchangeResY := exchangeString(x, y)
fmt.Println("exchangeString func result: ", exchangeResX, exchangeResY)
exchangeResX1, _ := exchangeString(x, y)
fmt.Println("exchangeString anonymity func result: ", exchangeResX1)
fmt.Println("【边长:1, 变长:2. 面积:2,周长:6】")
circumference1, area1 := funcDefineReturn(1, 2)
fmt.Println("circumference1:", circumference1, "area1", area1)
circumference2, area2 := funcDefineReturnNotUse(1, 2)
fmt.Println("circumference2:", circumference2, "area2", area2)
circumference3, area3 := funcNotDefineReturnUse(1, 2)
fmt.Println("circumference3:", circumference3, "area3", area3)
fmt.Println(getSum(1, 2, 3, 4, 5))
}
递归函数
- 递归函数介绍
- 函数自己调用自己,即:递归函数
- 递归函数需要 终止条件。 否则形成死循环
- 压栈
go code
package main
import "fmt"
func recursionFBI(frequency int) int {
if frequency <= 1 {
return frequency
}
return recursionFBI(frequency-1) + recursionFBI(frequency-2)
}
func main() {
for i := 1; i <= 10; i++ {
res := recursionFBI(i)
fmt.Printf("循环次数:%d。斐波那契数:%d\n", i, res)
}
}
defer 延时函数
- defer 延时函数。 多个defer时,按照逆向顺序执行。
- defer 场景: 文件流关闭,错误error,网络关闭等
go code
package main
import "fmt"
func test(s string) {
fmt.Println(s)
}
func main() {
test("1")
defer test("2")
test("3")
defer test("4")
defer test("5")
test("6")
}
defer 函数中的调用
go code
package main
import "fmt"
func test2(n int) {
fmt.Println("test2 函数中 defer n结果:", n)
}
func main() {
n := 1
fmt.Println("main n result start : ", n)
defer test2(n)
n++
fmt.Println("main n result end : ", n)
}
函数类型
go code
package main
import (
"fmt"
"reflect"
)
func test3() {
}
func test4(n1, n2 int) (int, int) {
return 0, 0
}
func test5(n1, n2 int, c ...string) (int, int, string) {
return 0, 1, "2"
}
func main() {
fmt.Printf("test3 函数类型: %T\n", test3)
fmt.Printf("test4 函数类型: %T\n", test4)
fmt.Printf("test5 函数类型: %T\n", test5)
var test6 func(int, int) (int, int)
test6 = test4
fmt.Printf("test6 函数类型: %T\n", test6)
fmt.Println("test6 函数内存地址: \n", reflect.ValueOf(test6).Pointer())
fmt.Println("test4 函数内存地址: \n", reflect.ValueOf(test4).Pointer())
f3, f4 := test6(1, 2)
fmt.Println(f3, f4)
}
匿名函数
go code
package main
import "fmt"
func main() {
anonymityFunc1 := func() {
fmt.Println("123")
}
anonymityFunc1()
anonymityFunc3 := func(a1, b1 int) int {
fmt.Println("匿名函数参数:a1", a1, "b1", b1)
return a1 + b1
}(1, 2)
fmt.Println("匿名函数 传参 的返回值:", anonymityFunc3)
}
回调函数
package main
import "fmt"
func main() {
fmt.Println("sum:", sum(1, 2))
sum1 := theReckonerFunc(1, 2, sum)
fmt.Println("theReckonerFunc 加法:", sum1)
fmt.Println()
sub := func(a, b int) int {
return a - b
}
sub1 := theReckonerFunc(1, 2, sub)
fmt.Println("theReckonerFunc 减法:", sub1)
fmt.Println()
multiplication1 := theReckonerFunc(2, 3, func(a, b int) int {
return a * b
})
fmt.Println("theReckonerFunc 乘法:", multiplication1)
fmt.Println()
punishment1 := theReckonerFunc(6, 3, func(a, b int) int {
if b == 0 {
return 0
}
return a / b
})
fmt.Println("theReckonerFunc 处法:", punishment1)
}
func theReckonerFunc(a, b int, fc func(a, b int) int) int {
fmt.Println("计算器函数计算方法:", fc)
return fc(a, b)
}
func sum(a, b int) int {
return a + b
}
go函数 闭包
- 一个外层函数中,有内层函数,该内层函数中,会操作外层函数的局部变量并且该外层函数的返回值就是这个内层函数。
- 在闭包结构中:局部变量的生命周期就会发生改变,
- 正常的局部变量会随着函数的调用而创建,随着函数的结束而销毁
- 但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁,因为内层函数还在继续使用.
package main
import "fmt"
func main() {
cf1 := closureFunc()
fmt.Printf("调用【closureFunc】函数。变量 cf1 内存地址:%p\n", &cf1)
fmt.Printf("调用【closureFunc】函数。变量 cf1 值:%d\n\n", cf1)
cf1Res := cf1()
fmt.Printf("调用【cf1】函数。结果 cf1 内存地址:%p\n", &cf1Res)
fmt.Printf("调用【cf1】函数。结果 cf1 值:%d\n\n", cf1Res)
cf1Resclosure := cf1()
fmt.Printf("调用【cf1 cf1Resclosure】函数。结果 cf1 cf1Resclosure 内存地址:%p\n", &cf1Resclosure)
fmt.Printf("调用【cf1 cf1Resclosure】函数。结果 cf1 cf1Resclosure 值:%d\n\n", cf1Resclosure)
fmt.Println("'-----------------'")
cf2 := closureFunc()
fmt.Printf("调用【closureFunc】函数。变量 cf2 内存地址:%p\n", &cf2)
fmt.Printf("调用【closureFunc】函数。变量 cf2 值:%d\n\n", cf2)
cf2Res := cf2()
fmt.Printf("调用【cf2】函数。结果 cf2 内存地址:%p\n", &cf2Res)
fmt.Printf("调用【cf2】函数。结果 cf2 值:%d\n\n", cf2Res)
}
func closureFunc() func() int {
i := 0
fmt.Printf("外层函数 内 i 变量 内存地址:%p\n", &i)
fmt.Printf("外层函数 内 i 变量 :%d\n\n", i)
retFunc := func() int {
fmt.Printf("调用 【前】函数。全局变量 i 内存地址:%p\n", &i)
fmt.Printf("调用 【前】函数。全局变量 i 值:%d\n\n", i)
i++
fmt.Printf("调用 【后】函数。全局变量 i 内存地址:%p\n", &i)
fmt.Printf("调用 【后】函数。全局变量 i 值:%d\n\n", i)
return i
}
fmt.Printf("内层函数 retFunc 内存地址:%p\n", &retFunc)
return retFunc
}