go 基础 -1

变量声明

• // var 变量名  变量类型
  var name string

• // 批量声明
  var （
      a string
      b int
  ）  

• //  初始化
  var 变量名 类型  =  表达式
  //   一次初始化多个
  var a, b = 1, 2

• //  变量推导，可以省略类型，根据右边定义的值自动推导类型
  var a = 123

• // 短变量声明,一般用于函数内部，不能在函数外使用
  a := 100

• // 匿名变量，用 _ 表示   用于获取多个值时忽略某个值
  
  package main
  
  import "fmt"
  
  func qwer() (int, string) {
      return 1, "haha"
  }
  
  func main()  {
      a, _ := qwer()
      _, b := qwer()
      fmt.Println("a=", a)
      fmt.Println("b=", b)
  }

常量

• // const  常量名 = xxx
  const a = 1

• // 多个常量
  
  const (
      b = 12
      c = 34
  )
  
  // const同时声明多个常量时，如果省略了值则表示和上面一行的值相同
  
  const (
      d = 12
      e 
  )

iota

iota是go语言的常量计数器，只能在常量的表达式中使用

• // iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。
  const (
      a = iota  // 0
      b         // 1
  )
  const c  =  iota  // 0
  

• // demo1  使用 _ 跳过某些值
  const (
          n1 = iota //0
          n2        //1
          _
          n4        //3
      )
  
  
  // demo2  iota声明中间插队
  const (
          n1 = iota //0
          n2 = 100  //100
          n3 = iota //2
          n4        //3
      )
  
  
  /* demo3  
  定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）
  */
  const (
          _  = iota
          KB = 1 << (10 * iota)
          MB = 1 << (10 * iota)
          GB = 1 << (10 * iota)
          TB = 1 << (10 * iota)
          PB = 1 << (10 * iota)
      )
  
  
  // demo4  多个iota定义在一起
  const (
      a, b = iota + 1, iota + 2 //1,2
      c, d                      //2,3
      e, f                      //3,4
      )

 

if

if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

// demo1

func main() {
	score := 65
	if score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

// demo2

func main () {
   if score := 65; score >= 90 {
      fmt.Println("A")
   } else if score > 75 {
      fmt.Println("B")
   } else {
      fmt.Println("C")
   }
}

demo1和demo2的区别在于score变量，demo1的score变量能在if判断完后继续使用，demo2的score只有在进行到判断那一步时才能使用，假如score用完就不需要了，可以使用demo2的写法。反之，则使用demo1的写法

 

for

for循环在返回true时，不停的循环，直到返回false就自动退出停止

for 初始语句;条件表达式;结束语句{
    循环体语句
}

写法一：
for i:=0; i<10; i++{
   fmt.Println(i)
}

写法二：忽略初始语句，但分号(;)还要保留
i := 0
for ; i<10; i++{
   fmt.Println(i)
}

写法三： 初始语句和结束语句都省略，类似于python中的while
i := 0
for i < 10 {
   fmt.Println(i)
   i++
}

无限循环
i := 0
for  {
   fmt.Println(i)
   i++
}

for range(键值循环)
Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：
数组、切片、字符串返回索引和值。
map返回键和值。
通道（channel）只返回通道内的值。

for练习题 99乘法表

// demo1

func main() {
    // 遍历, 决定处理第几行
    for y := 1; y <= 9; y++ {
        // 遍历, 决定这一行有多少列
        for x := 1; x <= y; x++ {
            fmt.Printf("%d*%d=%d ", x, y, x*y)
        }
        // 手动生成回车
        fmt.Println()
    }
}


// demo2

func main () {
    var x  = 1
    for x < 10 {
        x++
        for y :=1; y <= x; y++ {
            fmt.Printf("%v * %v = %v ", x , y, x*y)
        }
        fmt.Println()
    }
}


demo1是正确的，demo2由于先定义了变量x，导致进入for循环打印时，x已经经过x++，已经等于2了，所以打印有问题。由于x=9时，满足条件，打印时x=10，所以打印结果会是2开始，10结束。

 

 

break

break跳出for循环

func main()  {
   i := 1
   for ; i<10 ; i++ {
      fmt.Println(i)
      if i >= 5 {
         break
      }
   }
}

 

continue

continue跳过本次for循环，继续下一次， 在 continue语句后添加标签时，表示开始标签对应的循环

func main()  {
   i := 1
   for ; i<10 ; i++ {
      if i == 5 {
         continue
      }
      fmt.Println(i)
   }
}


func continueDemo() {
forloop1:
    for i := 0; i < 5; i++ {
        // forloop2:
        for j := 0; j < 5; j++ {
            if i == 2 && j == 2 {
                continue forloop1
            }
            fmt.Printf("%v-%v\n", i, j)
        }
    }
}

 

 

goto

goto  跳转至指定标签

func main()  {
   var breakFlag bool
   for i := 0; i < 10; i++ {
      for j := 0; j < 10; j++ {
         if j == 2 {
            breakFlag = true
            break
         }
         fmt.Printf("%v - %v \n", i, j)
         }
         if breakFlag {
            break
      }
   }
}



func main()  {
   for i := 0; i < 10; i++ {
      for j := 0; j < 10; j++ {
         if j == 2 {
            goto breakTag
         }
         fmt.Printf("%v - %v \n", i, j)
      }
   }
   return
   breakTag:
      fmt.Println("finish")
}

 

goto，break，continue三个语法都可以配合标签使用，区分大小写，Break与continue配合标签可用于多层循环的跳出，goto是调整执行位置，与其它2个语句配合标签的结果并不相同。

break不使用标签只是跳出上一层循环，使用标签则是跳出于标签同级的循环。

continue不加标签是跳过本次for循环，继续下一次，加标签是跳到与标签平级的for循环的下一次循环。

 

 

switch

#default每个switch只能有一个
func main()  {
   i := 1
   switch i {
   case 1:
      fmt.Println("a")
   case 2:
      fmt.Println("b")
   default:
      fmt.Println("nonono")
   }
}   

#多个值判断
func main() {
    switch n := 7; n {
    case 1, 3, 5, 7, 9:
        fmt.Println("奇数")
    case 2, 4, 6, 8:
        fmt.Println("偶数")
    default:
        fmt.Println(n)
    }
}

#使用表达式
func main() {
    age := 30
    switch {
    case age < 25:
        fmt.Println("好好学习吧")
    case age > 25 && age < 35:
        fmt.Println("好好工作吧")
    case age > 60:
        fmt.Println("好好享受吧")
    default:
        fmt.Println("活着真好")
    }
}

#fallthrough 执行满足条件的下一个case
func main()  {
   i := 1
   switch i {
   case 1:
      fmt.Println("a")
      fallthrough
   case 2:
      fmt.Println("b")
   default:
      fmt.Println("xxxx")
   }
}

 

 

参考 https://www.liwenzhou.com/posts/Go/go_menu/ 整理记录