GO 学习笔记——第二天 / 函数，工程管理-CFANZ编程社区

1.自定义函数

package main

import "fmt"

//伪代码
func main() {
 TestFun(1, 2, 3, 4, 5, 6)
}

//无参无返回值
func TestFun() {
 fmt.Println("TestFun null")
}

//有参无返回值
func TestFun(a int, b int) {
 fmt.Println("TestFun a:", a, ",b:", b)
}

//不定参数列表
func TestFun(args ...int) {
 fmt.Println(len(args))
 for i := 0; i < len(args); i++ {
  fmt.Println(args[i])
 }
 //可以迭代
 for i, data := range args {
  fmt.Println("i:", i, ":data:", data)
 }
}

//不定参数传递
func TestFun(args ...int) {
 //全部传递
 test(args...)
 //指定从第2个元素开始传递 2：和 :2 的区别
 test(args[2:]...)
}

func test(tmp ...int) {

}

//无参有返回值
func TestFun() (result string) {
 result = "Hello World!"
 return result
}

//多个返回值
func TestFun() (int, int, int) {

 return 1, 2, 3
}

//有参有返回值
func TestFun(a, b, int) (max, min, int) {
 if a > b {
  max = a
  min = b
 } else {
  max = b
  min = a
 }
 return max, min
}

2.递归函数

然而并没有什么卵用

3.函数类型

主要体现多态思想

package main

import "fmt"

func main() {
 var fTest FuncType
 fTest = Add
 c := fTest(1, 2)
 fmt.Println(c)
}

type FuncType func(int, int) int

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

回调函数

package main

import "fmt"

func main() {
 //c := Calu(1, 1, Add)
 c := Calu(10, 1, Jdd)
 fmt.Println(c)
}

type FuncType func(int, int) int

func Calu(a, b int, mTest FuncType) (result int) {
 result = mTest(a, b)
 return result
}

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

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

//无限实现对应的函数

4.匿名函数与闭包

匿名函数

package main

import "fmt"

func main() {

 a := 10
 str := "Hello"

 f1 := func() {
  fmt.Println("a:", a)
  fmt.Println("str:", str)
 }

 f1()

 type FuncType func()

 var f2 FuncType

 f2 = f1

 f2()

 //定义匿名函数同时调用
 func() {
  fmt.Println("a:", a)
  fmt.Println("str:", str)
 }()

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

 //带参数的匿名函数同时调用
 func(i, j int) {
  fmt.Println("i:", i)
  fmt.Println("j:", j)
 }(10, 20)

 //有参数有返回值
 f4, f5 := func(i, j int) (max, min int) {
  if i > j {
   max = i
   min = j
  } else {
   max = j
   min = i
  }
  return max, min
 }(10, 20)

 fmt.Println("f4:", f4)
 fmt.Println("f5:", f5)
}

闭包

所谓闭包就是一个函数捕获了和它同一作用域的常量和变量，这就意味着当闭包被调用的时候，不管在程序什么地方调用，闭包能使用这些常量或者变量，他不关心这些捕获了的常量和变量是否超出了作用域，所以只要闭包还在使用它，这些变量就会存在

package main

import "fmt"

func main() {

 a := 10
 str := "Hello"

 f1 := func() {
  fmt.Println("a:", a)
  fmt.Println("str:", str)
 }

 f1()

 type FuncType func()

 //声明
 var f2 FuncType

 f2 = f1

 f2()

 //定义匿名函数同时调用
 func() {
  fmt.Println("a:", a)
  fmt.Println("str:", str)
 }()

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

 //带参数的匿名函数同时调用
 func(i, j int) {
  fmt.Println("i:", i)
  fmt.Println("j:", j)
 }(10, 20)

 //有参数有返回值
 f4, f5 := func(i, j int) (max, min int) {
  if i > j {
   max = i
   min = j
  } else {
   max = j
   min = i
  }
  return max, min
 }(10, 20)

 fmt.Println("f4:", f4)
 fmt.Println("f5:", f5)

 fmt.Println("--------------")

 //传统函数
 fmt.Println(Test())
 fmt.Println(Test())
 fmt.Println(Test())
 fmt.Println(Test())
 fmt.Println(Test())

 fmt.Println("--------------")

 //闭包的特性
 f := Test01()
 fmt.Println(f())
 fmt.Println(f())
 fmt.Println(f())
 fmt.Println(f())
 fmt.Println(f())
}

//传统函数
func Test() int {
 //函数调用时才会分配空间
 var x int
 x++
 //函数调用完成后释放
 return x * x
}

//闭包函数
func Test01() func() int {
 var x int
 return func() int {
  x++
  return x * x
 }
}

5.延迟调用defer

在函数或者方法最后退出前调用

package main

import "fmt"

func main() {

 fmt.Println("1")
 //在函数结束前调用
 defer fmt.Println("2")
 fmt.Println("3")
 //输出1 3 2
}

如果一个函数中有多个defer，他会以后进先出的顺序执行，并且不管函数发生什么错误，都不会影响defer的执行

package main

import "fmt"

func main() {

 defer fmt.Println("1")
 defer fmt.Println("2")
 defer fmt.Println("3")

 //输出 3 2 1
}

和匿名函数的使用

package main

import "fmt"

func main() {

 a := 10
 b := 20

 defer func() {
  fmt.Println("a:", a, "b:", b)
 }()

 a = 11
 b = 21

 //输出 11 21
}

6.获取命令行参数

借助os包

package main

import "fmt"
import "os"

func main() {

 //接收用户传递的参数
 list := os.Args
 //参数的个数
 n := len(list)
 fmt.Println("n:", n)
 //输入 go run xx.go a b
 for i := 0; i < n; i++ {
  fmt.Println("list:", list[i])
 }
 //输出  xx.go  a b
}

7.作用域

定义在大括号里为局部变量，他的作用域就在括号内
定义在大括号外的为全局变量，他的作用域是全局
局部变量和全局变量同名的情况下优先局部变量

8.工程管理

导包

package main

//导入 1
import "fmt"

//导入 2
import (
 "fmt"
)

//导入 3 不需要函数调用
import . "fmt"

//导入 4 起别名
import put "fmt"

//导入 5 忽略此包
import _ "fmt"

func main() {
 put.Println("Hello ")
}

go env 查看GOPATH
多文件必须放在src
设置GOPATH环境变量
同一个目录的包名必须一致
同一个目录调用别的文件的函数直接调用即可
不用目录，包名不一样
调用不同包里的函数，格式：包名.函数名
首字母大写才能供别人调用

package main

import (
 "calu"
 "fmt"
)

func main() {
 a := calu.Add(1, 1)
 fmt.Println("a:", a)
}

init函数

导入包会先执行包的init函数