go语言2

所有文件内的package必须一样（可以改别名，但是各个文件内的别名要一样）

-函数高级

• 闭包函数

  闭包函数：定义在函数内部，对外部作用有引用
  内层函数：定义在函数内部的函数
  
  //(重点) go中函数内部定义的函数是不能有名的，需要定义匿名函数:没有名字
  
  func testt(a int)  {
    func() {
        fmt.Println("我是内层函数")
    }()//此处，内部函数定义了，就必须使用！！或者赋值给变量
  }
  
  
  func testt(a int) (func()) {//func（）是它的返回类型为函数！
    //var c int =100
    b:= func() {
        fmt.Println(a)
        fmt.Println("我是闭包函数")
    }
    return b
  }
  
  func testt(a int) func(){
    b:= func() {
        fmt.Println(a)
        fmt.Println("我是内部的函数")
    }
    return b
  }
  func main()  {
    a:=testt(111111)
    a()
  }

• 类型命别名

  type MyInt int
  
  var a MyInt=10
  var b int =90
  a=MyInt(b)
  fmt.Println(a)

-if-else

• -基本用法

  if 条件{
  }else if 条件{
  }else{
  }

• -在条件中可以定义变量

  if a:=80;a>90{
  }

-包

• 前言：其实就是导模块

        -新建一个文件夹，内部写很多go文件，但是包名必须一致
        -如果想在外部包使用，首字母必须大写；小写则是内部使用
        -在其他包中使用
            -import "mypackage"
            -mypackage.Test1()
        -下载第三方包
            go get github.com/astaxie/beego
            beego、gin

• 实例

  mypackage 1

  package mypackage
  
  func test(a,b int ) int {
    //fmt.Println(a+b)
    return a+b
  }
  

  mypackage 2

  package mypackage
  
  import "fmt"
  
  func Test2()  {
    fmt.Println(test(1,2))// 那边return才能用
    fmt.Println("这里是Test2")
  }

  调用

  // 包的使用
  package main
  
  import "mypackage"
  import "fmt"
  
  
  
  func main() {
  
    //想使用mypackage包下的test函数和test1函数
    mypackage.Test2()
    fmt.Println("这里是S3")
  
  }

-循环

-switch语句

• switch相当于if-else

  //基本用法
  a:=10
  switch a {
    case 1:
  fmt.Println("1")
    case 2:
  fmt.Println("2")
    case 10:
  fmt.Println("10")
  }

• default相当于else：最后其他情况

• 多值匹配

    a:=11
    switch a {
    case 1,4,5:
        fmt.Println("1")
    case 2,8,9:
        fmt.Println("2")
    case 10,11:
        fmt.Println("10")
    default:
        fmt.Println("不知道")
    }

• 无表达式的 switch：相当于a写在内部

    a:=11
    switch {
    case a > 10:
        fmt.Println("大于10")
    case a < 10:
        fmt.Println("小于10")
    default:
        fmt.Println("10")
    }

• Fallthrough（坠落，穿过）:达到条件，继续执行一个

    //Fallthrough
    a := 1
    switch a {
    case 1:
        fmt.Println("1")
        fmt.Println("xxxx")
        //穿透，无条件执行下一个case的内容
        fallthrough
    case 11:
        fmt.Println("11")
        test5()

-数组和切片

• 定义

  //数组 在定义阶段，长度和类型就固定了，以后不能更改
  
  var a [5]int  //定义了一个长度为5的int类型数组

• 指定数组位置的值

    //第99个位置设为99
    a :=[100]int{1,2,98:99,87:88}
  
    fmt.Println(a)

• 数组是值类型

  // 所有的函数传参都是copy传递
  //所有的函数传参都是copy传递,不会影响本身
  a:=[4]int{1,2,3}
  test6(a)
  fmt.Println(a,"111")
  
  func test6(b [4]int)  {
    b[0]=100
    fmt.Println(b)
  }

• 数组迭代（取值）

    var a=[4]int{1,2,}
    for i:=0;i<len(a);i++{
        fmt.Println(a[i])
    }

  • 通过range迭代

    var a=[4]int{1,2,}
    for i,_ := range a{
        fmt.Println("----",i)
    }

• 多维数组

  //多维数组
  var a [7][2]int//产生一个7位数字类型两两一对的数组
  a[0][1]=100
  fmt.Println(a)

编译型语言和位置无关

同一包下，无需导入，直接使用