Go学习笔记（8）Go的控制语句

文章目录

• 写在前面
• 条件语句
• 循环语句
• 选择语句
• 跳转语句

写在前面

    本文主要介绍Go的基本控制语句，包括条件语句、循环语句、选择语句、跳转语句，掌握并灵活运用这几种语句基本上就能玩转各种程序的逻辑啦

条件语句

    条件语句，即

if-else

结构语句，用于根据某个条件是否成立来执行相应的语句

• if

  结构

  var a = 10
  if a > 1 {
  	fmt.Println(a)
  }
             

• if-else

  结构

  var a = 10
  if a > 1 {
  	fmt.Println("a>1")
  } else{
  	fmt.Println("a<1")
  }
             

• if-else if

  结构 （可以嵌套多个

  else if

  结构）

  var a = 10
  if a > 0 {
  	fmt.Println("a>0")
  } else if a == 0 {
  	fmt.Println("a==0")
  } else {
  	fmt.Println("a<0")
  }
             

• 支持初始化表达式，即可以在

  if

  后面初始化一个变量，类似于我们在其它编程语言中使用

  for

  语句那样先定义一个变量。

  if a := 1; a > 0 {
  	fmt.Println(a)
  }
  if a,b := 1,2; a < b{
  	fmt.Println("a<b")
  }
             

      需要注意的是，初始化语句中的变量是一个局部变量，只在该条件语句内有效。如果外部有同名变量，在该语句内将被隐藏

      在使用条件语句时，需要注意以下几点格式：

  • 条件表达式没有括号
  • 左大括号

    {

    必须要和

    if

    或

    else (if)

    在同一行
  • 代码块中间的右大括号

    }

    必须位于

    else (if)

    在同一行
  • 大括号不能省略，即使括号里只有一条语句
  • 支持单行模式（全部写在一行），不推荐

循环语句

    循环语句用于重复执行程序中某些语句，在Go中循环语句只有个

for

结构一种，没有

while

，但是Go中的

for

语句比其它编程语言中的

for

要灵活得多，足以应多各种循环操作

• 经典计数结构

  for i := 0; i < 3; i++ {
  	fmt.Println(i)
  }
             

      这个结构应该不用多作解释了，不过有几点需要注意下：

1. for

   后面的语句不需要用括号括起来，用分号相隔即可
2. 左大括号

   {

   必须和

   for

   语句在同一行
3. 条件判断语句每次循环都会执行，因此不建议在条件判断语句中使用函数，尽量提前计算好
4. 计数变量可以使用多个，如下所示

   for i, j := 1, 10; i < j; i, j = i+1, j-1 {
   		fmt.Println(i, j)
   }
              

• 条件判断结构

  i := 5
  for i >= 0 {
  	fmt.Println(i)
  	i--
  }
             

      这种结构就是省略掉了计数器的定义以及修改，只保留中间的条件判断语句。实现了

  while(条件){...}

  的功能
• 无限循环结构

  i := 1
  for{
  	i++
  	if i > 3 {
  		break
  	}
  	fmt.Println(i)
  }
             

      这种结构省略了

  for

  后面的循环控制语句，直接

  for{}

  的形式，其实这是一个无限循环体。当然，它可以在循环体内搭配条件语句和

  break

  语句来跳出循环体，像上面的代码所示，实际上实现了

  do{...}while(条件)

  的功能

• for-range

  结构

  array := [5]int{1, 2, 3, 4, 5}
  for i, v := range array {
  	fmt.Println(i, v)
  }
             

      

  for-range

  是go特有的一种循环结构，可以用来迭代数组、切片、map等集合，如上面代码所示是遍历一个数组

  array

  ，其中返回的变量

  i

  ，

  v

  分别是数组的索引和对应的值。需要注意的是：返回的值仅仅是集合中对应索引的值的拷贝，因此对它作任何修改是不会影响原来集合中的值的。比如在上面的代码中，如果在循环体内对

  v

  进行修改或者赋值，并不会影响原来的数组

  array

  中的值。

      如果只需要返回索引或者值中的一个，可以用

  _

  来替代抛弃值：

  array := [5]int{1, 2, 3, 4, 5}
  for _, v := range array {
  	fmt.Println(v)
  }
             

选择语句

    选择语句

switch

用于多分支选择的情况，与其它编程语言相比，go的

switch

语句更加灵活。

• 基本结构

  switch val {
  	case val1:
  		...
  	case val2:
  		...
  	default:
  		...
  }
             

  • val

    可以是任何类型，

    val1

    、

    val2

    则可以同类型的任何值。类型不局限于基本类型，还可以是表达式，但必须是相同的类型
  • 左大括号

    {

    必须和

    switch

    在同一行
  • 一旦匹配到某个分支，在执行完相应的代码后会退出整个

    switch

    代码块，不需要使用

    break

    来显示退出
  • 如果执行完某个分支后，还希望继续执行后续代码，可以使用

    fallthrough

    关键字来执行

  i := 0
  switch i {
  	case 0 : 
  		fmt.Println("0")    //进入该分支执行完后即退出switch
  	case 1:  
  		fmt.Println("1")    //不会进入这个分支
  }
  
  switch i {
  	case 0 : 
  		fmt.Println("0")     //首先进入这个分支执行
  		fallthrough
  	case 1:  
  		fmt.Println("1")    //由于上面有fallthrough，所以会进入本分支执行
  }
             

  • case

    后面还可跟多个值，同时测试多个可能符合条件的值，只要有一个符合即进入分支

  i := 3
  switch i {
  	case 0, 1:
  		fmt.Println("0 or 1")
  	case 2, 3:
  		fmt.Println("2 or 3")         //进入该分支
  	default:
  		fmt.Println("none")
  }
             

• 直接判断条件分支结构

  a := 1
  b := 2
  switch {
  	case a < b:
  		fmt.Println("a<b")
  	case a == b:
  		fmt.Println("a==b")
  	case a > b:
  		fmt.Println("a>b")
  }
             

      这种结构中，

  switch

  不提供任何被判断的值，直接在每个

  case

  分支中测试条件是否成立，条件成立则执行分支。可以用来替代

  if-else

  语句。
• 包含初始化语句结构

  switch a,b:=1,2; {
  	case a < b :
  		fmt.Println("a<b")
  	case a == b:
  		fmt.Println("a==b")
  	case a > b:
  		fmt.Println("a>b") 
  }
             

      这种结构中，

  switch

  后面可以初始化一些变量值

跳转语句

    go中跳转语句包括了

break

、

continue

、

goto

三种，它们都可以配合标签使用

• break语句

  for i := 0; i < 10; i++ {
  	for j := 0; j < 5; j++ {
  		if j > 3 {
  			break
  		}
  	}
  }
  //运行结果
  0 0
  0 1
  1 0
  1 1
  2 0
  2 1
             

      默认用法下，执行

  break

  会跳出（结束）该语句所在的那层循环。但如果搭配标签使用，

  break

  则可以跳出和标签同层的循环

  LABEL:
  for {
   	for i := 0; i < 10; i++ {
   		if i > 2 {
   			break LABEL
   		} else {
   			fmt.Println(i)
   		}
   	}
   }
   fmt.Println("OK")
  //运行结果
  0
  1
  2
  OK
             

• continue语句

  for i := 0; i < 5; i++ {
  	if i == 3 {
  		continue
  	}
  	fmt.Println(i)
  }
   //运行的结果是
  0 0
  1 0
  1 2
  2 0
  2 2
  3 0
  3 2
  4 0
  4 2
             

      默认用法下，

  continue

  是结束本次循环，进入下一次循环，它的作用范围也是

  continue

  所在的同一层循环。同样的，

  continue

  也可以搭配标签使用，这样就可以作用与标签所在同一层的循环体。

  Label:
  for i := 0; i < 5; i++ {
  	for j := 0; j < 3; j++ {
  		if j == 1 {
  			continue Label
  		}
  		fmt.Println(i, j)
  	}
  }
  //运行的结果是
  0 0
  1 0
  2 0
  3 0
  4 0
             

• goto语句

      

  goto

  语句是用于调整程序执行的位置，

  goto

  语句需要配合标签使用，直接将程序指向标签所在的位置往下执行。需要注意的是，

  goto

  的标签一般要放在循环之后。

  for i:=1 {
  	i++
  	if i > 3 {
  		goto LABEL
  	}
  	fmt.Println(i)
  }
  LABEL:
  fmt.Println("goto label")
  //运行结果
  1
  2
  3
  goto label
             

      此外，如果定义了标签名却没有使用，将引起编译错误