Golang入门第二天

1. 选择结构
2. 循环结构
3. 流程控制
4. 类型转换
5. 类型别名
6. 函数调用
7. 函数类型
8. 匿名函数和闭包
9. 回调函数

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)

}

输出结果

这里是第二天学习
这里是判断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
这里是直接调用的无参无返回的匿名函数
这里是直接调用的有参有返回的匿名函数