09-GoLang流程控制

选择结构if

• C语言中有三目运算符 ?:

• Go语言中没有，所有用三目解决的问题使用 if-else 来解决

• C语言中的if选择结构有三种格式

  格式一：

  if(条件表达式){
  被控制的语句;
  }

  格式二：

  if(条件表达式){
  被控制的语句;
  }else{
  被控制的语句;
  }

  格式三：

  if(条件表达式){
  被控制的语句;
  }else if(条件表达式){
  被控制的语句;
  }else{
  被控制的语句;
  }

• Go语言中的if选择结构也有三种格式, 并且和C语言中的格式类似

  格式一：

  if 初始化表达式;条件表达式 {
  被控制的语句;
  }

    // 注意点: 如果将变量定义到if的初始化表达式中, 那么变量只能在if结构中使用
  // 这样做的目的是为了提升性能, 如果变量只在选择结构中使用, 
   //那么建议定义到初始化表达式中, 这样只要选择结构结束了, 那么变量就释放了
    if age := 19; age >=18 {
      fmt.Println("开网卡")
  }
   fmt.Println("买饮料")
  fmt.Println(age) // 报错
  
    //若要继续使用变量，则定义到if结构外面
  // age := 17
   //if age >=18 {
   // fmt.Println("开网卡")
   }
  

  格式二：

  if 初始化表达式;条件表达式 {
  被控制的语句;
  }else{
  被控制的语句;
  }

  // 注意点: 在if初始化表达式中定义的变量, 是在整个if选择结构中都可以使用的,
   // 不仅仅只是在if{}中可以使用, 在else{}中也可以使用
   if age := 17;age >= 18 {
       fmt.Println("开网卡")
   }else{
       fmt.Println("回家叫家长")
       fmt.Println(age)
   }
    fmt.Println("买饮料")
  

  格式三：

  if 初始化表达式;条件表达式{
  被控制的语句;
  }else if 初始化表达式;条件表达式{
  被控制的语句;
  }else{
  被控制的语句;
  }

  // 注意点:
   // 1.不仅仅if后面可以写初始化表达式, 所有的elseif后面也可以写初始化表达式
   // if后面的初始化表达式在整个选择结构中都可以使用
   // elseif后面的初始化后表达式, 只能在当前的elseif和后续的elseif/else中使用, 不能在初始化表达式定义之前使用
   // 2.如果if初始化表达式定义的变量和elseif初始化表达式定义的变量同名了, 那么会出现覆盖现象(重新定义了变量)
   age := 3
   fmt.Println(&age)
   if age:=15; age >= 22 {
       fmt.Println("该上班了")
       fmt.Println(age)
   }else if fmt.Println(&age); age >= 18{
       fmt.Println("该上大学了")
       fmt.Println(age)
   }else if age := 666; age >= 12{
       fmt.Println("该上中学了")
       fmt.Println(age) // 这里访问的是当前elseif定义的age
       fmt.Println(&age)
   }else{
       fmt.Println("该干嘛干嘛")
       fmt.Println(age)
   }
   fmt.Println(&age)
   fmt.Println("other")
  

  

• C语言中if选择结构的特点:
  1、条件表达式非零即真
  2、if后面的{}可以省略
  3、如果省略大括号, 不能定义行的变量

• Go语言if选择结构的特点:
  1、条件表达式必须是返回布尔类型的值, 没有非零即真的概念
  2、if后面的{}不能省略
  3、可以在条件表达式前面添加初始化表达式
  4、每个条件表达式的前面都可以添加初始化表达式
  5、多个初始化表达式定义了同名的变量, 访问时采用就近原则(会重新定义变量，地址不同)

选择结构switch

• C语言中的switch结构
  switch(值){
  case 值:
  被控制语句;
  break;
  case 值:
  被控制语句;
  break;
  default:
  被控制语句;
  break;
  }

• Go语言中的Switch结构和C语言类似
  switch 初始化表达式; 值{
  case 值:
  被控制语句;
  case 值:
  被控制语句;
  default:
  被控制语句;
  }

  //age := 22
   //switch age {
   //case 22:
   //  fmt.Println("该上班了")
   //case 18:
   //  fmt.Println("该上大学了")
   //default:
   //  fmt.Println("该干嘛干嘛")
   //}
  
   switch age := 3; age {
   case 22:
       fmt.Println("该上班了")
   case 18:
       fmt.Println("该上大学了")
   default:
       fmt.Println("该干嘛干嘛")
   }
  

• 注意点:
  1.和C语言不一样, Go语言的switch可以传递小数

switch num := 18.0; num { // 传递一个小数
    case 22:
        fmt.Println("该上班了")
    case 18:
        fmt.Println("该上大学了")
    default:
        fmt.Println("该干嘛干嘛")
    }

2.和C语言不一样, Go语言switch中还可以添加初始化表达式
3.和C语言不一样, Go语言不用编写break语句, 默认就不会穿透
4.在Go语言中, 如果想要穿透, 必须手动添加一个fallthrough

switch num := 18.0; num { // 传递一个小数
    case 22:
        fmt.Println("该上班了")
    case 18:
        fmt.Println("该上大学了")
        fallthrough // 告诉系统需要穿透
    default:
        fmt.Println("该干嘛干嘛")
    }

5.Go语言中的switch可以当做if来使用（可以写表达式）

    switch num := 50;{    //将判断放到case语句里面了
    case num >=0 && num <=50:
        value := 666
        fmt.Println("0~50之间的数")
        fmt.Println(value)
    case num >50 && num <=100:
        fmt.Println("51~100之间的数")
    default:
        fmt.Println("其它区间")
    }

6.default可以不写, 也可以写到其它位置, 无论写到哪都会最后判断执行
7.case后面定义变量不用添加大括号{}

循环结构

• 在C语言中循环结构有三个 for/while/dowhile
• 在Go语言中循环结构只有一个 for
  因为while/dowhile能做的for都能做, 所以Go只保留了for循环
• C语言for循环的格式
  for(初始化表达式;条件表达式;增量表达式){
  需要循环操作的语句;
  }
• Go语言的for循环和C语言非常非常非常像
  for 初始化表达式;条件表达式;增量表达式{
  需要循环操作的语句;
  }

  for num := 0; num < 5; num++{
        fmt.Println("发射小星星")
    }
  

• 特点:
  1.没有非零即真的概念, 条件表达式的返回值必须是布尔类型
  2.不能省略大括号
  3.最简单的死循环
  for{}

跳转

break

• 在C语言中有四大跳转语句 break continue goto return
• 在Go语言中也有四大跳转语句 break continue goto return
• 在C语言中break的应用范围：switch语句和循环语句
• 在Go语言中一样是：switch语句和循环语句（但是Go语言的switch语句中默认就不会穿透, 所以break写不写都行, 一般都不写）

    switch num := 2; num {
    case 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
        break     //一般不写
    default:
        fmt.Println("OTHER")
    }

    for num := 1; num <= 10; num++ {
        fmt.Println(num)
        if num == 5{
            break
        }
    }

• 注意点：Go语言中的break可以跳转到指定的标签, 但是标签只能定义在前面, 并且跳转到标签之后循环不会被再次执行，标签和循环之间不能编写其它语句

lyw:
    //fmt.Println("start") // 标签和循环之间不能添加任何语句
    for num := 1; num <= 10; num++ {
        fmt.Println(num)
        if num == 5{
            break lyw
        }
    }
//lyw: // 标签只能写在前面
    fmt.Println("end")

continue

• 在C语言中continue只能用于循环结构
• 在Go语言中和C语言一样, 也只能用于循环结构
• 使用的各种特性和C语言都一样, 唯一不一样的就是可以跳转到指定的标签

LNJ:
    for num := 1; num <= 10; num++ {
        if (num % 2) == 0{
            continue LNJ
        }
        fmt.Println(num)
    }

• 注意点:
  • 如果跳转到指定的标签, 对于单层循环来说没有任何意义, 和不指定标签的效果一样

    for num := 1; num <= 10; num++ {
    if (num % 2) == 0{
        continue
    }
    fmt.Println(num)
    

  }
  ```
  • 如果跳转到指定的标签, 对于多层循环来说才有意义, 结束当前内循环, 跳到下一次外循环

      LNJ:
          for i:=1; i<=5;i++{
              fmt.Println(i)
              for j:=1; j <=10; j++{
                 if (j % 2) == 0{
                    continue LNJ
                  }
              fmt.Println("---------", j)
           }
    

  }
  ```
  • 其它的注意点和break跳转到标签一样
  • 标签只能定义在前面, 标签和循环之间不能添加其它语句

goto

• C语言中的goto可以在同一个函数中随便乱跳
• Go语言中的goto也可以在同一个函数中随便乱跳
• 注意点:
  • 可以往前跳, 也可以往后跳
  • 标签和跳转语句之间可以编写其它的代码

    num := 1
outer:
    fmt.Println("start")
    if(num <= 10){
        fmt.Println(num)
        num++
        goto outer
    }
    fmt.Println("come here")

    for i:=1; i <= 10; i++{
        fmt.Println(i)
        if i == 5{
            goto LYW
        }
    }
LYW:
    fmt.Println("come here")

return
略