go基础

go基础

• 数组

  //数组定义
  var a [3] bool
  //初始化
  var b [3] int = [3]{1,2,3}
  // 数组的遍历
  // 1.索引遍历
  city := [...]string{"背景", "团啊", "你好"}
  for i := 0; i < len(city); i++ {
      fmt.Println(city[i])
  }
  // 2.for range 遍历
  for i, v := range city {
      fmt.Println("i = ", i)
      fmt.Println("v = ", v)
  }
  

• 指针

  //指针 不存在指针操作
  1.取地址 =》  &
  2.根据地址取值：*	
  

  make和new

  1.make和new都是分配内存的

  2.new 很少用，一般用来给基本类型申请内存，string\int,返回对应类型的指针

  3.make是用来给slice、map、chan申请内存的，make函数返回的对应的是对应的三个基本类型本身

• map

  1.map是引用类型，无序的

  //map
  var m1 map[string]int
  m1 = make(map[string]int, 10)
  fmt.Println(m1 == nil)
  for k, v := range m1 {
      fmt.Println(k,v)
  }
  

  2.删除map中的元素

  delete(m1,"key")
  

  3.元素类型为map类型的切片

  var s1 = make([]map[int]string, 0, 10)
  //元素类型为map的切片
  var s1 = make([]map[int]string, 10, 10)
  s1[0] = make(map[int]string, 1)
  s1[0][10] = "你还是"
  fmt.Println(s1)
  //值为且切片类型的map
  var m2 = make(map[string][]int, 10)
  m2["内发货"] = []int{2, 3, 45}
  fmt.Println(m2)
  

• 函数

  //函数定义、
   //go是强类型语言
  func funcname() returnvalue{
      
  }
  //1.带返回值 ret是已经声明的
  func sum(x int, y int) (ret int) {
      ret = x + y
      return //这里可以不写ret
  }
  //2.没有返回值
  func f1(x int, y int) {
      fmt.Println(x+y)
  }
  //可变长参数
  func f2(x string, y...int) {
      //y的类型是切片
  }
  //defer 
  //defer执行时机是在返回值赋值完成和RET指令之间
  

  2.变量的作用域

  //全局变量和局部变量
  

  3.函数类型作为变量和返回值

  //函数作为入参变量
  func f(){
  	fmt.Prinrln("x")
  }
  func main() {
  	a := f
  	fmt.Println(a) //函数类型
  }
  //函数作为参数
  func f2(x func()) {
      x()
  }
  //函数作为返回值
  func f3() func() {
      return f()
  }
  

  4.匿名函数

  没有函数名字

  var f = func(x, y int) {
  	fmt.Println(x+y)
  }
  func main(){
      //函数内部
      f1 := func() {
          
      }
      //只执行一次的函数还可以简写成立即执行函数
      func() {
          
      }() //()的意思是执行
  }
  

  5.闭包

  //闭包
  func f1() {
  	//1
  }
  func f2(x, y int) {
      //2
  }
  func f3(f func(int, int), m, n int) func() {
      f4 := func(){
          f(m,n)
      }
      return f4
  }
  //底层原理
  //1.函数可以作为返回值
  //2.函数内部查找变量的顺序，先在自己内部找，找不到往外层找
  func add() func(int) int {
      var x int =100
      return func(y int) int{
          x += y
          return x
      }
  }
  //闭包等于 函数 + 外部变量的引用
  
  
  //panic 程序崩溃退出
  //err := recover() recover 必须搭配defer使用
  //defer 一定要在可能引发panic的语句之前定义 
  

  
  **结构体**
  
  1.结构体定义：
  
  ​