Golang入门第二天
- 选择结构
- 循环结构
- 流程控制
- 类型转换
- 类型别名
- 函数调用
- 函数类型
- 匿名函数和闭包
- 回调函数
- defer
package main
import (
"fmt"
)
// 函数1
func demo1() {
fmt.Println("这是无参无返回的方法demo1")
}
// 函数2
func demo2() (a int, b float64) {
fmt.Println("这是无参有固定返回的方法demo2")
a, b = 1, 3.14
return
}
// 函数3
func demo3(A int, B float64) (a int, b float64) {
fmt.Println("这是有固定参固定返回的方法demo3")
a, b = A, B
return
}
// 函数4
func demo4(A int, B float64, args ...int) (a int, b float64) {
fmt.Println("这是有不定长参固定返回的方法demo4")
a, b = A, B
return
}
// 函数5
func demo5(A int, B float64, args ...int) (a int, b float64) {
fmt.Println("这是不定长参传递的方法demo5")
demo4(A, B, args...) // 完全传递不定参数args的值
demo4(A, B, args[2:]...) // 从角标2开始，传递不定长度参数args的值
a, b = A, B
return
}
// 递归方法求和
func demo6(a int) (result int) {
if a < 1 {
return a
}
fmt.Println("这里是递归方法，实现累加demo6")
result = a + demo6(a-1)
return
}
// 函数类型实现1
func demo7(a, b int) (max, min int) {
if a > b {
max, min = a, b
} else {
max, min = b, a
}
fmt.Println("这里是函数类型myfunc的实现1：比大小demo7")
return
}
// 函数类型
type demoType func(int, int) (int, int)
// 回调函数，有一个方法参数为函数类型的成为回调函数
func demo8(a, b int, c demoType) (result1, result2 int) {
result1, result2 = c(a, b)
fmt.Println("这里是回调函数demo8")
return
}
func main() {
fmt.Println("这里是第二天学习")
// 判断
if a0 := 1; a0 > 0 {
fmt.Println("这里是判断if")
} else if a0 < 0 {
fmt.Println("else if")
}
a1 := demo6(0)
switch a1 {
case 1:
fmt.Println("case 1")
case 2:
fmt.Println("case 1")
default:
fmt.Println("default")
}
// 循环
const a2 = iota
for a3 := a2; a3 > 6; a3++ {
if a3 > 5 {
break
} else {
a3++
}
fmt.Println("这里是循环")
}
// 迭代
const str1 = "这里是练习第二天"
for i, data := range str1 {
fmt.Printf("str[%d] = %c\n", i, data)
}
// 类型转换 bool 与 int 不能互相转换
bo1 := 3.14
bo2 := 1
bo2 = int(bo1)
fmt.Println("类型转换 = ", bo2)
// 类型别名
type long int64
var l1 long = 31456
fmt.Println("类型别名 = ", l1)
// 函数调用
demo1()
demo2()
demo3(1, 3.14)
demo4(1, 3.14, 2, 3)
demo5(1, 3.14, 2, 3)
demo6(3)
// 函数类型，实现多态，(函数指针？)
type myfunc func(int, int) (int, int)
var func1 myfunc = demo7
func1(10, 20)
fmt.Printf("func1.type = %T\n", func1)
// 匿名函数和闭包：A closure is a function value that references variables from outside its body.
// 这是 A Tour of Go 上的定义，闭包 是一种引用了外部变量的函数。但我觉得这个定义还不够准确，闭包 应该是引用了外部变量的 匿名函数。
// 闭包 其实就是匿名函数，但其实两者是不能直接划等号的。闭包 是一种特殊的匿名函数，是匿名函数的子集。
// 闭包以引用的方式捕获外部变量，它不关心这些捕获了的变量和常量是否已经超出了作用域，所以只有闭包还在使用它，这些变量就还会存在
// 匿名函数，可以直接操作
func1 = func(a, b int) (max, _ int) {
if a > b {
max, _ = a, b
} else {
_, max = b, a
}
fmt.Println("这里是函数类型myfunc的实现2：返回最大值")
return
}
func1(10, 20)
// 回调函数，模板思想
demo8(1, 2, func(i int, i2 int) (int, int) {
fmt.Println("这里是回调函数匿名形参")
return i + i2, i2 - i
})
// 匿名函数可直接调用
func() {
fmt.Println("这里是直接调用的无参无返回的匿名函数")
}()
//有参数有返回值的匿名函数
func(i, j int) (max, min int) {
fmt.Println("这里是直接调用的有参有返回的匿名函数")
return
}(1, 2)
// defer延迟调用，多个defer遵循调用栈先进后出规则
var (
a int = 10
b int = 20
)
defer func(a, b int) {
fmt.Printf("这里是带参defer测试, a = %d, b= %d\n", a, b)
}(a, b)
defer func() {
fmt.Printf("这里是无参defer测试, a = %d, b= %d\n", a, b)
}()
a, b = 100, 200
fmt.Printf("这里是defer测试, a = %d, b= %d\n", a, b)
}
输出结果
这里是第二天学习
这里是判断if
default
str[0] = 这
str[3] = 里
str[6] = 是
str[9] = 练
str[12] = 习
str[15] = 第
str[18] = 二
str[21] = 天
类型转换 = 3
类型别名 = 31456
这是无参无返回的方法demo1
这是无参有固定返回的方法demo2
这是有固定参固定返回的方法demo3
这是有不定长参固定返回的方法demo4
这是不定长参传递的方法demo5
这是有不定长参固定返回的方法demo4
这是有不定长参固定返回的方法demo4
这里是递归方法，实现累加demo6
这里是递归方法，实现累加demo6
这里是递归方法，实现累加demo6
这里是函数类型myfunc的实现1：比大小demo7
func1.type = main.myfunc
这里是函数类型myfunc的实现2：返回最大值
这里是回调函数匿名形参
这里是回调函数demo8
这里是直接调用的无参无返回的匿名函数
这里是直接调用的有参有返回的匿名函数
这里是defer测试, a = 100, b= 200
这里是无参defer测试, a = 100, b= 200
这里是带参defer测试, a = 10, b= 20
