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 的类型 :
    fallthrough
    1
    1
    def

  • 循环控制Goto、Break、Continue

请关注我的个人博客

讨论数量: 0
(= ̄ω ̄=)··· 暂无内容!

请勿发布不友善或者负能量的内容。与人为善,比聪明更重要!