Go开发基础入门——4

请关注我的个人博客

流程控制

• if

     if 布尔表达式 {
  /* 在布尔表达式为 true 时执行 */
  }
  
     *不支持三元操作符(三目运算符) "a > b ? a : b"。
  
  
     if else：
  
     if 布尔表达式 {
     /* 在布尔表达式为 true 时执行 */
     } else {
     /* 在布尔表达式为 false 时执行 */
     }

• for

  Go语言的For循环有3中形式，只有其中的一种使用分号。
  
  for init; condition; post { }
  for condition { }
  for { }
  init： 一般为赋值表达式，给控制变量赋初值；
  condition： 关系表达式或逻辑表达式，循环控制条件；
  post： 一般为赋值表达式，给控制变量增量或减量。
  for语句执行过程如下：
  ①先对表达式 init 赋初值；
  ②判别赋值表达式 init 是否满足给定 condition 条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。
  
  公式：
  for [condition |  ( init; condition; increment ) | Range]
  {
      statement(s)
  }
  
  替代 while(true)的方法：
  
  for {
      
  }
  
  
  
  因为比较简单，我这里说一个稍微复杂一点的就是 range ，那么请先看range的知识点
  
  下面是一个栗子：
  func changeBigSmallWord(str string) string{
      result := ""
      for i,value := range str{
          if i%2==0 {
              result += strings.ToUpper(string(value))
          }else {
              result += strings.ToLower(string(value))
          }
      }
      return result
  }
  循环时用到range 即迭代传入的 str 相当于遍历了

• range

  range = 迭代器的效果
  简单理解成遍历没有问题
  
  for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
  
  str := "abcdefgHiGKLmn"
  
  result := ""
  for _, value := range str {
      result += string(value)
  }

  • 举个栗子

    //字母大小写变化
    
    func changeBigSmallWord(str string) string{
        result := ""
        for i,value := range str{
            if i%2==0 {
                result += strings.ToUpper(string(value))
            }else {
                result += strings.ToLower(string(value))
            }
        }
        return result
    }
    func main{
        str2 := "abcdefGHIGKLMN"
        result2 := changeBigSmallWord(str2)
        fmt.Println(result2)
    }
    
    >>AbCdEfGhIgKlMn

    for 和 for range有什么区别?
    
    主要是使用场景不同
    
    for可以
    
    遍历array和slice
    遍历key为整型递增的map
    遍历string
    
    for range可以完成所有for可以做的事情，却能做到for不能做的，包括
    
    遍历key为string类型的map并同时获取key和value
    遍历channel

• switch

  switch var1 {
      case val1:
          ...
      case val2:
          ...
      default:
          ...
  }
  
  变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

  • 举个栗子

    package main
    
    import "fmt"
    
    func main() {
    /* 定义局部变量 */
    var grade string = "B"
    var marks int = 90
    
    switch marks {
        case 90: grade = "A"
        case 80: grade = "B"
        case 50,60,70 : grade = "C"
        default: grade = "D"  
    }
    
    switch {
        case grade == "A" :
            fmt.Printf("优秀!\n" )     
        case grade == "B", grade == "C" :
            fmt.Printf("良好\n" )      
        case grade == "D" :
            fmt.Printf("及格\n" )      
        case grade == "F":
            fmt.Printf("不及格\n" )
        default:
            fmt.Printf("差\n" )
    }
    fmt.Printf("你的等级是 %s\n", grade )
    }
    
    
    优秀!
    你的等级是 A

    比较好理解，和java中的类似，下面来看一些不太一样的，比如case中包含 && || 等，或者是判断某个 interface 变量中实际存储的变量类型
    
    定义语句： Type switch
    Type Switch 语法格式如下：
    switch x.(type){
        case type:
        statement(s)      
        case type:
        statement(s)
        /* 你可以定义任意个数的case */
        default: /* 可选 */
        statement(s)
    }
    
    实例：
    package main
    
    import "fmt"
    
    func main() {
        var x interface{}
        //写法一：
        switch i := x.(type) { // 带初始化语句
        case nil:
            fmt.Printf(" x 的类型 :%T\r\n", i)
        case int:
            fmt.Printf("x 是 int 型")
        case float64:
            fmt.Printf("x 是 float64 型")
        case func(int) float64:
            fmt.Printf("x 是 func(int) 型")
        case bool, string:
            fmt.Printf("x 是 bool 或 string 型")
        default:
            fmt.Printf("未知型")
        }
        //写法二
        var j = 0
        switch j {
        case 0:
        case 1:
            fmt.Println("1")
        case 2:
            fmt.Println("2")
        default:
            fmt.Println("def")
        }
        //写法三
        var k = 0
        switch k {
        case 0:
            println("fallthrough")
            fallthrough
            /*
                Go的switch非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；
                而如果switch没有表达式，它会匹配true。
                Go里面switch默认相当于每个case最后带有break，
                匹配成功后不会自动向下执行其他case，而是跳出整个switch,
                但是可以使用fallthrough强制执行后面的case代码。
            */
        case 1:
            fmt.Println("1")
        case 2:
            fmt.Println("2")
        default:
            fmt.Println("def")
        }
        //写法三
        var m = 0
        switch m {
        case 0, 1:
            fmt.Println("1")
        case 2:
            fmt.Println("2")
        default:
            fmt.Println("def")
        }
        //写法四
        var n = 0
        switch { //省略条件表达式，可当 if...else if...else
        case n > 0 && n < 10:
            fmt.Println("i > 0 and i < 10")
        case n > 10 && n < 20:
            fmt.Println("i > 10 and i < 20")
        default:
            fmt.Println("def")
        }
    }
    
    结果为：
    x 的类型 :<nil>
    fallthrough
    1
    1
    def

• 循环控制Goto、Break、Continue

请关注我的个人博客