Day_02

1.无参数无返回值函数的使用

package main

import "fmt"

//无参无返回值函数的定义
func MyFunc() {
	a := 666
	fmt.Println("a= ", a)
}

func main() {
	//无参无返回值函数的调用，函数名()
	MyFunc()
}

 2.普通参数列表

package main

import "fmt"

//有参无返回值函数的定义，普通参数列表
func MyFunc01(a int) {
	//a = 111
	fmt.Println("a = ", a)
}

//传递多个参数
func MyFunc02(a int, b int) {
	fmt.Printf("a = %d,b = %d\n", a, b)
}

func MyFunc03(a, b int) {
	fmt.Printf("a = %d,b = %d\n", a, b)
}

func MyFunc04(a int, b string, c float64) {

}

func MyFunc05(a, b string, c float64, d, e int) {

}

func main() {
	MyFunc01(666)
	MyFunc02(123, 456)
	MyFunc03(888, 999)
}

 3.不定参数类型

package main

import "fmt"

//...int类型这样的类型，...type不定参数类型
//不定参数一定只能放在形参中的最后一个参数
func MyFunc01(args ...int) { //传递的参数可以是0个或多个
	fmt.Printf("传递了%d个参数\n", len(args)) //获取用户传递参数的数量

	//不定参数数量返回的是一个列表，所以我们可以用for循环将获取其值
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Println("========================================")
	//也可以用这种方式，返回2个值，第一个是下标，第二个是下标所对应的数
	for i, data := range args {
		fmt.Printf("第二种方式：args[%d] = %d\n", i, data)
	}
}

func main() {
	MyFunc01()
	fmt.Println("++++++++++++++++++++++++++++++++++")
	MyFunc01(1)
	fmt.Println("++++++++++++++++++++++++++++++++++")
	MyFunc01(1, 2, 3)
}

 4.不定参数传递

package main

import "fmt"

func myfunc(tmp ...int) {
	for _, data := range tmp {
		fmt.Println("data = ", data)
	}
	fmt.Println("我是myfunc+++++++++")
}

func myfunc2(tmp ...int) {
	for _, data := range tmp {
		fmt.Println("data = ", data)
	}
	fmt.Println("我是myfunc2+++++++++")
}

func test(args ...int) {
	//全部元素传递给myfunc
	myfunc(args...)
	//只想把后2个参数传递给另外一个函数使用
	//myfunc2(args[:2]...)	//从args[0]~args[2](不包括args[2]),传递过去
	myfunc2(args[2:]...) //从args[2]开始（包括本身），把后面所有元素传递过去
}

func main() {
	test(1, 2, 3, 4)

}

 5.一个返回值

package main

import "fmt"

//无参有返回值；只有一个返回值
//有返回值的函数需要通过return中断函数，通过return返回
func myfunc01() int {
	return 666
}

//给返回值起一个变量名，go推荐写法,也是常用写法
func myfunc02() (result int) {
	result = 777
	return
}

func main() {
	//无参有返回值函数调用，定义一个变量接收返回值
	var a = myfunc01()
	fmt.Println("a", a)

	b := myfunc01()
	fmt.Println("b= ", b)

	c := myfunc02()
	fmt.Println("c= ", c)

}

 6.多个返回值

package main

import "fmt"

//多个返回值
func myfunc01() (int, int, int) {
	return 1, 2, 3
}

//Go官方推荐写法
func myfunc02() (a int, b int, c int) {
	a, b, c = 111, 222, 333
	return
}

func myfunc03() (a, b, c int) {
	a, b, c = 444, 555, 666
	return
}

func main() {
	//函数调用
	a, b, c := myfunc03()
	fmt.Printf("a = %d,b = %d,c = %d\n", a, b, c)
}

 7.有参数有返回值

package main

import "fmt"

//函数定义
func MaxAndMin(a, b int) (max, min int) {
	if a > b {
		max = a
		min = b
	} else {
		max = b
		min = a
	}
	return //有返回值的函数，必须通过return返回
}

func main() {
	max, min := MaxAndMin(50, 10)
	fmt.Printf("最大值是:%d,最小值是:%d\n", max, min)

	//通过匿名变量丢弃某个返回值
	i, _ := MaxAndMin(50, 10)
	fmt.Printf("i = %d", i)

}

 8.普通函数的调用流程

package main

import "fmt"

func funcb() (b int) {
	b = 222
	fmt.Println("funcb b = ", b)
	return
}

func funca() (a int) {
	a = 111
	b := funcb()
	fmt.Println("funca  b = ", b)

	//调用另一个函数
	fmt.Println("funca a = ", a)

	return //返回
}

func main() {
	fmt.Println("main  func")
	a := funca()
	fmt.Println("main a = ", a)
}

 9.函数递归的调用流程

package main

import "fmt"

func test(a int) {
	if a == 1 { //函数终止调用的条件，非常重要
		fmt.Println("a = ", a)
		return //终止函数调用
	}
	//函数调用自身
	test(a - 1)
	fmt.Println("a = ", a)
}

func main() {
	test(3)
	fmt.Println("main")
}

 10.通过递归实现的累加

package main

import "fmt"

//普通方式实现累加
func test01() (sum int) {
	for i := 1; i <= 100; i++ {
		sum += i
	}
	return
}

//递归方式实现累加（递减）
func test02(i int) int {
	if i == 1 {
		return 1
	}
	return i + test02(i-1)
}

//递归方式实现累加（递增）
func test03(i int) int {
	if i == 100 {
		return 100
	}
	return i + test03(i+1)
}

func main() {
	var sum int
	//sum = test01()
	//sum = test02(100)
	sum = test03(1)
	fmt.Println("sum = ", sum)

}

 11.函数类型

package main

import "fmt"

func Add(a, b int) int {
	return a + b
}

func Minus(a, b int) int {
	return a - b
}

//函数也是一种数据类型，通过type给一个函数类型起名
//FuncType它是一种函数类型
type FuncType func(int, int) int //没有函数名字，没有{}

func main() {
	var result int
	result1 = Add(5, 1) //传统调用方式
	fmt.Println("result1 = ", result1)

	//声明一个函数类型的变量，变量名叫fTest
	var fTest FuncType
	fTest = Add             //是变量就可以赋值
	result2 = fTest(10, 20) //等价于Add(10,20)
	fmt.Println("result2 = ", result2)

}

 12.回调函数

package main

import "fmt"

type FuncType func(int, int) int

//实现加法
func Add(a, b int) int {
	return a + b
}

//实现减法
func Minus(a, b int) int {
	return a - b
}

//实现乘法
func Mul(a, b int) int {
	return a * b
}

//回调函数，函数有一个参数是函数类型，这个函数就是回调函数
//计算器，可以进行四则运算
//多态，多种形态，调用同一个借口，不同的表现，可以实现不同的功能，加减乘除
//先有想法，后面再实现功能，这就是回调函数的意义
func Calc(a, b int, fTest FuncType) (result int) {
	fmt.Println("Calc")
	result = fTest(a, b) //这个函数还没有实现
	//result = Add(a, b)	//Add()必须先定义，才能调用
	return

}

func main() {
	a := Calc(10, 5, Mul) //那么在这里我想实现减法，我在上面定义一下，然后拿到这里修改一下Add为Minus就可以了,类似的乘法，除法同理，有利于程序的扩展
	fmt.Println("a = ", a)
}

 13.匿名函数和闭包

package main

import "fmt"

func main() {
	a := 10
	str := "Mike"

	//匿名函数，没有函数名字,函数定义，暂时还没有调用
	f1 := func() { //自动推导类型
		fmt.Println("a = ", a)
		fmt.Println("str = ", str)
	}
	f1()

	//给一个函数类型起别名
	type FuncType func() //函数没有参数，没有返回值
	//声明变量
	var f2 FuncType
	f2 = f1
	f2()

	//定义匿名函数，同时调用
	func() {
		fmt.Printf("a = %d,str = %s\n", a, str)
	}() //后面的括号代表调用此匿名函数

	//带参数的匿名函数
	f3 := func(i, j int) {
		fmt.Printf("i = %d,j = %d\n", i, j)
	}
	f3(1, 2)

	//定义匿名函数，同时调用
	func(i, j int) {
		fmt.Printf("i = %d,j = %d\n", i, j)
	}(10, 20)

	//匿名函数，有参数有返回值
	x, y := func(i, j int) (max, min int) {
		if i > j {
			max = i
			min = j
		} else {
			max = j
			min = i
		}
		return
	}(50, 20)
	fmt.Printf("x = %d,y = %d\n", x, y)
}

 14.闭包捕获外部变量的特点

package main

import "fmt"

func main() {
	a := 10
	str := "Mike"

	func() {
		//闭包以引用方式捕获外部变量
		a = 666
		str = "go"
		fmt.Printf("内部：a = %d,str = %s\n", a, str)
	}() //()代表直接调用
	fmt.Printf("外部：a = %d,str = %s\n", a, str)
}

/*
打印结果:
内部：a = 666,str = go
外部：a = 666,str = go
*/

 15.闭包的特点

package main

import "fmt"

//函数的返回值是一个匿名函数，返回一个函数类型
func test02() func() int {
	var x int //没有初始化，值为0

	return func() int {
		x++
		return x * x
	}
}

func main() {
	//返回值为一个匿名函数，返回一个函数类型，通过f来调用返回的匿名函数，f来调用闭包函数
	//它不关心这些捕获了的变量和常量是否已经超出了作用域
	//所以只有闭包还在使用它，这些变量就还会存在。
	f := test02()
	fmt.Println(f) //1
	fmt.Println(f) //4
	fmt.Println(f) //9
	fmt.Println(f) //16
	fmt.Println(f) //25
}

func test01() int {
	//函数被调用时，x才分配空间，才初始化为0
	var x int //没有初始化，值为0
	x++
	return x * x //函数调用完毕，x自动释放

}

func main01() {
	fmt.Println(test01())
	fmt.Println(test01())
	fmt.Println(test01())
	fmt.Println(test01())

}

 16.defer的使用

package main

import "fmt"

/*
	关键字defer用于延迟一个函数或者方法（或者当前所创建的匿名函数）的执行，
	defer语句只能出现在函数或方法的内部。
*/

func main() {
	//defer延迟调用 在函数结束前调用，所以可以看到aaaaaaaa先打印
	defer fmt.Println("bbbbbbbbbbbbbbbbbbbb")
	fmt.Println("aaaaaaaaaaaaaaaaaaaa")

}

/*
运行结果：
aaaaaaaaaaaaaaaaaaaa
bbbbbbbbbbbbbbbbbbbb
*/

 17.多个defer的执行顺序

package main

import "fmt"

/*
如果一个函数中有多个defer语句，他们会以为LIFO（后进先出）的顺序执行，哪怕函数或某个延迟调用发生错误，这些调用依旧会被执行。
*/

func test(x int) {
	result := 100 / x
	fmt.Println("result = ", result)
}

func main() {

	defer fmt.Println("aaaaaaaaaaaaaaaaaaaa")
	defer fmt.Println("bbbbbbbbbbbbbbbbbbbb")

	//调用一个函数，导致内存出问题,故意让除以0
	defer test(0)
	defer fmt.Println("ccccccccccccccccc")
}

/*
运行结果：
ccccccccccccccccc
bbbbbbbbbbbbbbbbbbbb
aaaaaaaaaaaaaaaaaaaa
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.test(0x0)
        D:/Let's  Go/17_多个defer的执行顺序.go:6 +0xd9
main.main()
        D:/Let's  Go/17_多个defer的执行顺序.go:18 +0x15e
exit status 2
*/

 18.defer和匿名函数结合使用

package main

import "fmt"

func main() {
	a := 10
	b := 20
	defer func(a, b int) {
		fmt.Printf("a = %d,b = %d\n", a, b)
	}(a, b) //代表调用此匿名函数,把参数传递过去，已经先传递参数，只是没有调用
	a = 111
	b = 222
	fmt.Printf("外部：a = %d,b = %d\n", a, b)
	//输出结果为先打印外部: a=111,b=222之后打印的是a = 10,b = 20
}

func main01() {
	a := 10
	b := 20

	defer func() {
		fmt.Printf("a = %d,b = %d\n", a, b)
	}() //代表调用此匿名函数
	a = 111
	b = 222
	fmt.Printf("外部：a = %d,b = %d\n", a, b)
	//输出结果为两个打印都为a = 111,b = 222
}

 19.获取命令行参数

package main

import "fmt"
import "os"

func main() {
	//接收用户传递的参数，都是以字符串方式传递到一个列表里面
	list := os.Args

	n := len(list)
	fmt.Println("n = ", n)

	//xxx.exe   a  b
	for i := 0; i < n; i++ {
		fmt.Printf("list[%d] = %s\n", i, list[i])
	}

	//第二种方式
	for _, data := range list {
		fmt.Printf(" %s\n", data)
	}

}

 20.局部变量

package main

import "fmt"

func test() {
	a := 10
	fmt.Println("a = ", a)
}

func main() {
	//定义在{}里面的变量就是局部变量，只能在{}里面有效
	//执行到定义变量那句话，才开始分配空间，离开作用域
	//作用域，变量起作用的范围
	{
		i := 10
		fmt.Println("i = ", i)
	}
	if flag := 3; flag == 3 {
		fmt.Println("flag = ", flag)
	}
}

 21.全局变量

package main

import "fmt"

func test() {
	fmt.Println("test a = ", a)
}

//定义在函数外部的变量是全局变量,全局变量在任何地方都能使用
var a int

func main() {
	a = 10
	fmt.Println("a = ", a)
	test()
}

 22.不同作用域同名变量

package main

import "fmt"

var a byte //全局变量

func main() {
	var a int //局部变量

	//1.不同作用域，允许定义同名变量
	//2.使用变量的原则，就近原则
	fmt.Printf("%T\n", a) //int

	{
		var a float32
		fmt.Printf("2: %T\n", a) //float32
	}

	test()
}

func test() {
	fmt.Printf("3: %T\n", a) //unit8		就是byte类型

}

 23.工作区

Go代码必须放在工作区中。工作区其实就是一个对应于特定工程的目录，它应包含3个子目录：src目录、pkg目录和bin目录。
src目录：用于以代码包的形式组织并保存Go源码文件。（比如：.go  .c  .h 等等）
pkg目录：用于存放经由go install命令构建安装后的代码包（包含Go库源码文件）的 ".a"归档文件。
bin目录：与pkg目录类似，在通过go install命令完成安装后，保存由Go命令源码文件生成的可执行文件。

目录src用于包含所有的源代码，是Go命令行工具一个强制的规则，而pkg和bin则无需手动创建，如果必要Go命令行工具在构建过程中会自动创建这些目录。

需要特别注意的是，只有当环境变量GOPATH中只包含一个工作区的目录路径时，go install命令才会把命令源码安装到当前工作区的bin目录下。
若环境变量GOPATH中包含多个工作区的目录路径，像这样执行go install命令就会失败，此时必须设置环境变量GOBIN。

GOPATH设置
为了能够构建这个工程，需要先把所需工程的根目录加入到环境变量GOPATH中。否则，即使处于同一工作目录（工作区），代码之间也无法通过绝对代码包路径完成调用。

 24.导入包的常用方式

package main

/*
//方式1
import "fmt"
import "os"

//方式2 常用
import (
	"fmt"
	"os"
)

//方式3 .操作
import . "fmt" //调用函数，无需通过包名
import . "os"

//方式4	给包起别名
import io "fmt"

func main() {
	io.Println("这是别名方式导入包")

}

//忽略此包
import _ "fmt"		//该操作其实是引入该包，而不直接使用包里面的函数，而是调用了该包里面的init函数



func main() {
	fmt.Println("this is a test")
	fmt.Println("os.Args = ", os.Args)
	fmt.Println("this is a test")
}
*/

 25.工程管理

同级目录：
1、分文件编程（多个源文件），必须放在src目录
2、设置GOPATH环境变量
3、同一个目录，包名必须一样
4、go env查看go相关的环境路径
5、同一个目录，调用别的文件的函数，直接调用即可，无需包名引用
不同级目录：
1、不同目录，包名不一样
2、调用不同包里面的函数，格式：包名：函数名（）
3、调用别的包的函数，这个包函数名字如果是小写，无法让别人调用，要想别人调用，必须首字母大写