一、函数
（一）无参无返回值函数
//无参无返回值函数的定义
func MyFunc() {
a := 666
fmt.Println("a=", a)
}
func main() {
//无参无返回值函数的调用：函数名()
MyFunc()
}（二）普通参数列表
//有参无返回值函数的定义，普通参数列表
//定义函数时，在函数名后面（）定义的参数叫形参
//参数传递，只能由实参传递给形参，不能反过来，单向传递
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 int, b string, c float64) {
fmt.Printf("a=%d,b=%s, c=%f\n", a, b, c)
}
func main() {
//有参无返回值函数调用：函数名（所需参数）
//调用函数传递的参数叫实参
MyFunc01(666)
MyFunc02(666, 777)
MyFunc03(666, "abc", 4.14)
}（三）不定参数类型
//注意：不定参数，一定（只能）放在形参中的最后一个参数
func MyFunc02(args ...int) { //...int类型这样的类型，...type不定参数类型
fmt.Println("len(args)=", len(args)) //获取用户传递参数的个数
for i := 0; i < len(args); i++ {
fmt.Printf("args[%d]=%d\n", i, args[i])
}
//返回2个值，第一个是下标，第二个是下标所对应的数
for i, data := range args {
fmt.Printf("args[%d]=%d\n", i, data)
}
}
//固定参数一定要传参，不定参数根据需求传参，不定参数放最后
func MyFunc03(a int, args ...int) {
}
func main() {
MyFunc02(1)
MyFunc02(1, 2, 3)
MyFunc03(111, 1, 2, 3)
}
（四）不定参数传递
func myfunc02(tmp ...int) {
for _, data := range tmp {
fmt.Println("data=", data)
}
}
func test(args ...int) {
//全部元素传递给mufunc01
myfunc02(args...)
myfunc02(args[:2]...) //从args[2]开始（不包括本身），把前面所有元素传递过去
myfunc02(args[2:]...) //从args[2]开始（包括本身），把后面所有元素传递过去
}
func main() {
test(1, 2, 3, 4)
}（五）一个返回值函数
//无参，有返回值，只有一个返回值
//有返回值的函数，需要通过return来中断函数，返回
func myfunc01() int {
return 666
}
//给返回值起一个变量名，go语言推荐写法
func myfunc02() (result int) {
result = 666
return
}
func myfunc03() (result int) {
return 666
func main() {
var a int
a = myfunc01()
fmt.Println("a=", a)
b := myfunc01()
fmt.Println("b=", b)
c := myfunc02()
fmt.Println("c=", c)
}（六）多个返回值
//多个返回值
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 = 111, 222, 333
return
}
func main() {
a, b, c := myfunc02()
fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
}（七）有参有返回值函数
func MaxAndMin(a, b int) (max, min int) {
if a > b {
max = a
min = b
} else {
min = a
max = b
}
return
}
func main() {
max, min := MaxAndMin(10, 20)
fmt.Printf("max=%d,min=%d\n", max, min)
m, _ := MaxAndMin(10, 20) //匿名函数丢弃某个返回值
fmt.Printf("max=%d\n", m)
}（八）函数调用流程
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.Printf("main a=%d\n", a)
}
//函数调用流程：先调用后返回，先进后出
//函数递归，函数调用自己本身，利用此特点（九）函数递归调用流程
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")
}//实现1+2+3+...+100
func test01() (sum int) {//非递归
for i := 1; i <= 100; i++ {
sum += i
}
return
}
func test02(i int) int {//1+2+...+100
if i == 1 {
return 1
}
return i + test02(i-1)
}
func test03(i int) int {//100+99+...+1
if i == 100 {
return 100
}
return i + test03(i+1)
}
func main() {
var sum int
sum = test01()
fmt.Println("sum=", sum)
sum = test02(100)
fmt.Println("sum=", sum)
sum = test03(1)
fmt.Println("sum=", sum)
}（十）函数类型
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
result = Add(1, 1)
fmt.Println("result=", result)
var fTest FuncType//声明一个函数类型的变量，变量名叫fTest
fTest = Add //是变量就可以赋值
result = fTest(10, 20) //等价于Add(10,20)
fmt.Println("result=", result)
fTest = minus
result = fTest(10, 5)
fmt.Println("result=", result)
}（十一）回调函数
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 Div(a, b int) int {
return a / b
}
//回调函数，函数有一个参数是函数类型，这个函数就是回调函数
//计算机，可以进行四则运算
//多态，多种形态，调用同一个接口，不同的表现，可以实现不同表现，加减乘除
//现有想法，后面再实现功能
func Calc(a, b int, fTest FuncType) (result int) {
fmt.Println("Calc")
result = fTest(a, b) //这个函数还没有实现
return
}
func main() {
a := Calc(1, 1, Add)
fmt.Println("a=", a)
a = Calc(1, 1, Minus)
fmt.Println("a=", a)
}（十二）匿名函数与闭包
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("a=%d,b=%d\n", i, j)
}
f3(1, 2)
func(i, j int) {//定义匿名函数，同时调用
fmt.Printf("a=%d,b=%d\n", i, j)
}(3, 4)
x, y := func(i, j int) (max, min int) {//匿名函数，有参有返回值
if i > j {
max = i
min = j
} else {
max = j
min = i
}
return
}(10, 20)
fmt.Printf("x=%d,y=%d\n", x, y)（十三）闭包捕获外部变量的特点
a := 10
str := "mike"
func() {//闭包以引用的方式捕获变量
a = 666
str = "go"
fmt.Printf("inner a=%d,str=%s\n", a, str)
}() //()代表直接调用
fmt.Printf("outer a=%d,str=%s\n", a, str)（十四）闭包的特点
func test01() int {
//函数被调用时，x才分配空间，才初始化为0
var x int //没有初始化，值为0
x++
return x * x //函数调用完毕，x自动释放
}
//函数的返回值是一个匿名函数，返回一个函数类型
func test02() func() int {
var x int
return func() int {
x++
return x * x
}
}
func main() {
fmt.Println(test01())
fmt.Println(test01())
//返回值为一个匿名函数,返回一个函数类型，通过f来调用返回的匿名函数，f来调用闭包函数
//它不关心这些捕获了的变量和常量是否已经超出了作用域
//所以只有闭包还在使用它，这些变量就会存在
f := test02()
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
}（十五）defer的使用
//defer延迟调用，main结束前调用
defer fmt.Println("bbbbbbbbbbbbbb")
fmt.Println("aaaaaaaaaaaaaa")（十六）多个defer的执行顺序
func test(x int) {
result := 100 / x
fmt.Println(result)
}
func main() {
//如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行，
//哪怕函数或某个延迟返回发生错误，这些调用依旧会被执行
defer fmt.Println("aaaaaaaaaaaaaa")
defer fmt.Println("bbbbbbbbbbbbbbbbbb")
//调用一个函数导致内存出问题
defer test(0)
defer fmt.Println("cccccccccccccccccccc")
}（十七）defer和匿名函数的结合使用
a := 10
b := 20
defer func() {
fmt.Printf("a=%d,b=%d\n", a, b)
}() //()代表调用此匿名函数
defer func(a, b int) {
fmt.Printf("a=%d,b=%d\n", a, b)
}(a, b) //()代表调用此匿名函数,把参数传递过去，已经先传递参数，只是因为defer而没有调用
defer func(a, b int) {
fmt.Printf("a=%d,b=%d\n", a, b)
}(1, 2)
a = 111
b = 222
fmt.Printf("外部：a=%d,b=%d\n", a, b)（十八）获取命令行参数
list := os.Args//接受用户传递的参数，都是以字符串方式传递的
n := len(list)
fmt.Println("n=", n)
for i := 0; i < n; i++ {
fmt.Printf("list[%d]=%s\n", i, list[i])
}
for i, data := range list {
fmt.Printf("list[%d]=%s\n", i, data)
}//要导入os包（十九）局部变量
//定义在{}里面的变量就是局部变量，只能在{}里面有效
//执行到定义变量那句话的手，才开始分配空间，离开作用域会自动释放
//作用域，变量起作用的范围
//a = 111
{
i := 10
fmt.Println("i=", i)
}
//i = 111
if flag := 3; flag == 3 { //flag离开这个if语句就不存在了
fmt.Println("flag=", flag)
}
flag = 4（二十）全局变量
//定义在函数外面的变量是全局变量
//全局变量在任何地方都能使用
var a int
func test() {
fmt.Println("a=", a)
}
func main() {
a = 10
fmt.Println("a=", a)
test()
}（二一）不同作用域同名变量
var a byte //全局变量
func main() {
var a int //局部变量
//1.不同作用域允许定义同名变量
//2.使用变量的原则，就近原则
fmt.Printf("1:%T\n", a)
{
var a float32
fmt.Printf("2:%T\n", a)
}
test()
}
func test() {
fmt.Printf("3:%T\n", a)
}（二二）导入包
/*//方式一
//import "fmt" //导入包必须使用
//import "os"
//方式二
import (
"fmt"
"os"
)
func main() {
fmt.Println("testetst")
fmt.Println("os.Args=", os.Args)
}*/
//.操作，不推荐
/*import . "fmt"//调用函数无需通过包名
func main() {
Println("testetst")
}*/
//给包起别名
/*import io "fmt"
func main() {
io.Println("trstteste")
}*/
//忽略此包
import _ "fmt"
func main() {
fmt.Println("trstteste")
}二、工程管理
（一）说明
1.分文件编程（多个源文件），必须放在src目录
2.设置GOPATH环境变量
3.同一个目录，包名必须一样
4.go env 查看go相关的环境路径
5.同一个目录，调用别的文件的函数，直接调用即可，无需包名引用
6.不同目录，包名不同
7.调用不同包里面的函数，格式：包名.函数名（）
8.如果调用别的包的函数，这个包函数名字如果是小写，无法让别人调用，要想别人能调用，必须首字母大写
（二）总结
1.src：放源代码
如果有多个文件或多个包
1）配置GOPATH环境变量，如：D:\software\go\code\day02\25_工程管理（配置src同级目录的绝对路径）
2）如果想要自动生成bin和pkg目录，需要使用 go install命令，除了要配置GOPATH环境变量还要配置GOBIN环境变量
2.bin:放可执行程序
3.pkg:放平台相关的库