1.流程控制

  1. - 控制代码的执行顺序，根据基本结构实现复杂的程序流程控制。基本结构分别有顺序结构、选择结构和循环结构。

2.顺序结构

  1. - 顺序结构按照一步步写出的语句执行，当没有别的流程控制语句时程序可以从上到下依次执行。

3.选择结构

  1. - 选择结构由if语句和switch语句实现，它们分别是条件分支和多分支语句。

4.循环结构

  1. - 条件满足的情况，会去循环0 - N次：for

if

  1. - 条件分支语句是根据表达式的真假决定程序的走向。其中的判断条件是控制程序执行的关键，用 if...else来表示。格式如下：
  2.     * <font style="color:rgb(51, 51, 51);">if 单独存在</font>
  3.     * <font style="color:rgb(51, 51, 51);">if ... else</font>
  4.     * <font style="color:rgb(51, 51, 51);">if ... elseif ... else if ... else</font>
  1. func main() {
  2.      var num int = 15
  3.      // if
  4.      if num > 100{
  5.         fmt.Println("num>100")
  6.      }
  7.      if num < 100 {
  8.         fmt.Println("num<100")
  9.      }
  11.      //if ... else
  12.      if num>100{
  13.         fmt.Println("num>100")
  14.      }else{
  15.         fmt.Println("num<100")
  16.      }
  18.      // if ... elseif ... else if ... else
  19.      var score int 
  20.      fmt.Println("请输入数字：")
  21.      fmt.Scan(&score)   //用于控制台接收输入
  22.      if score>=90 && score<=100{
  23.         fmt.Println("A")
  24.      }else if score>=80 &&score<=90{
  25.         fmt.Println("B")
  26.      }else if score>=70 &&score<=80{
  27.         fmt.Println("C")
  28.      }else if score>=60 &&score<=70{
  29.         fmt.Println("D")
  30.      }else {
  31.         fmt.Println("E")
  32.      }
  33. }
  1. **switch**

1.基本使用switch…case…defalut

  1. score := 100
  2.      switch score{
  3.      case 100:
  4.         fmt.Println(score)  //输出100
  5.      case 90:
  6.         fmt.Println(score)
  7.      default:
  8.         fmt.Println(score)
  9.      }
  10. //省略条件 默认为true
  11. switch {
  12.      case true:
  13.         fmt.Println("true")  //输出true
  14.      case false:
  15.         fmt.Println("false")
  16.      default:
  17.         fmt.Println("defalut")
  18.      }
  1.         2.需要多个条件输出，case穿透：fallthrough
  1. f := true
  2.      switch f{
  3.      case true:
  4.         fmt.Println("true") //输出true
  5.         fallthrough            //强行执行下一个case
  6.      case false:
  7.         fmt.Println("false") //输出false，
  8.          fallthrough         //强行执行下一个case
  9.      case true:
  10.         fmt.Println("true2") //输出true2
  11.      default:
  12.         fmt.Println("defalut")
  13.      }

3.终止case：break

  1. f := true
  2.      switch f{
  3.      case true:
  4.         fmt.Println("true")  //输出true
  5.         fallthrough             //强行执行下一个case
  6.      case false:
  7.         fmt.Println("false") //输出true2
  8.         fallthrough             //强行执行下一个case
  9.      case true:
  10.         if f==true{
  11.             break            //满足条件 终止输出
  12.         }
  13.         fmt.Println("true2")
  14.      default:
  15.         fmt.Println("defalut")
  16.      }

for循环

for i:=0;i<=10;i++{

fmt.Println(“xxx”)

}

  1. func main() {
  2.      sum:=0  //接收最后的结果
  3.      for i := 0; i <=10 ; i++ {
  4.         sum+=i
  5.      }
  6.         fmt.Println(sum)
  7. }

for循环的结束与终止：continue 与 break

continue 结束当前循环，继续下一次循环

  1.   break  终止整个循环
  1. for i:=0;i<=10;i++{
  2.         fmt.Println(i)
  3.         if i==5{
  4.             fmt.Println("i=5,停止循环")
  5.             break
  6.         }
  7.      }
  8.      for i := 0; i < 10; i++ {
  10.         if i==5 {
  11.             fmt.Println("跳出当前循环,不往下执行，继续下一个循环")
  12.             continue
  13.         }
  14.         fmt.Println(i)
  15.      }
  1. func main() {
  2.     var admin string
  3.     var pass int
  4.     sum := 0 //记录登录错误次数
  5.     for {
  6.         //接收输入的用户名密码
  7.         fmt.Println("请输入用户名：")
  8.         fmt.Scan(&admin)
  9.         fmt.Println("请输入密码：")
  10.         fmt.Scan(&pass)
  11.         if admin == "admin" && pass == 123 {
  12.             fmt.Println("登录成功")
  13.             break
  14.         } else {
  15.             fmt.Println("请重新输入用户名和密码")
  16.             sum++
  17.             if sum == 3 {
  18.                 fmt.Println("已连续输入错误3次，已退出")
  19.                 break
  20.             }
  21.         }
  23.     }
  24. }