Go基础编程---函数

函数（无返回值）

//1、无参，无返回值
func test () {
}
//2、有参，无返回值,调用时多少形参就要传多少实参
func test1( a int, b string){}
//3、不定参数类型   ...type  只能放在形参的最后一个参数
func test2 ( a string, args  ...int){}
//4、 不定参数传递
func test3(args ... int){
  test4(args...)  //将传递过来的参数全部给test4
  test4(args[:2]) // 将传递过来的参数的前2个给传递到test4中，包左不包右
}
func test4(args ...int){}

函数（有返回值）

\\1、无参无返回值 :只有一个返回值（多种写法）
func test1() int {
    return  666
}
func test1() （result int ） {  // 给返回值起别名,go推荐
    return  666
}
func test1() (result int){   // 常用写法
      result = 666
      retrun
}
\\ 2、有多个返回值
func test2() (int, int, int){
     return 1,2,3
}
func test2() (a ,b,c int){   // go 推荐做法
     a,b,c = 1,2,3
      return 
}

函数（有参有返回值）

// 求最大小值
func main()  {
  max,min := getMaxAndMin(1,2,3,333,3,4,4,5,23)
  fmt.Printf("max is %d ,min is %d",max ,min)
}
func getMaxAndMin(args ...int)(max,min int){
    max = args[0]
    min = args[0]
    for _,v := range args{
      if max < v{
        max = v
      }
      if min > v{
        min = v
      }
    }
    return
}
// 递归实现累加
func diGui (a int) int{
  if a ==1 {
    return 1
  }
  return diGui(a -1) + a
}

函数类型

Go中函数也是一种类型，可以通过type 定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型。

type functype  func ( int, int) int  // 声明一个函数类型，不能有函数名
定义函数类型主要用于回调，话说是类似多态
通过一个函数执行加减乘除
func diGui (a int) int{
  if a ==1 {
    return 1
  }
  return diGui(a -1) + a
}
func add (a,b int) int {
  return a + b
}
func cal (a,b int) int {
  return a - b
}
type Yunsuan func(int,int) int
func  caculate(a,b int, funcs Yunsuan) int{
   return funcs(a,b)
}
func main()  {
  fmt.Printf("result is %d",caculate(3,22,cal))
}

匿名函数

f1 := func (){
  xxxx
}
or 
func () {
}()

闭包(函数里面返回函数，函数里的变量能记住函数外部的变量)

func bibao () func () int {
   x := 1
   return func () int {
      x ++
      return x
   }
}

defer 延迟调用（可以在函数返回前执行一些操作）最常用的就是打开一个资源（例如一个文件、数据库连接等）时就用defer延迟关闭改资源，以免引起内存泄漏,

越后面的defer表达式越先被调用

func main () {
   defer  fmt.Println("aaaa")
   fmt.Println("bbbbb")
   // 先打bbbbb再打出aaaa,在函数执行完的最后一步执行defer那行
}
// 多个 defer 先进后出
for i:=1; i <= 3; i++{
      defer fmt.Println(i)   // 3,2,1
}
// defer和匿名函数结合
func main () {
     a  := 10
     b  :=  20
     defer func (a, b int) {
           fmt.Printf("a = %d, b = %d ", a, b)
      }(a,b)  // 此时的a=10 和 b = 20 已经传递过来了
     a = 111
     b = 222
     fmt.Printf("外部的 a = %d, b = %d\n", a, b) // 先打印111,222，然后是 10,20
}

defer 延迟函数参数

func main() {
    a := 1
    defer as(a)
    a = 5
    as(a)
    // a is  5
    // a is  1
}
func as(i int) {
    fmt.Println("a is ", i)
}

获取命令行参数

func getParam () {
   list := os.Args
   for i,v := range list {
     fmt.Printf("第 %d 个，的值为 %s\n", i, v)
   }
}

工程管理

待续...

init 函数

当导入一个包的时候会先执行那个包的 init 函数，再执行main函数，若是main包中有init函数，那么init函数也调用在mian之前。

go install 命令的使用

需要添加GOBIN环境变量为工作目录的bin文件，然后go install 会生成2个文件 bin和pkg。