条件语句

switch语句

  • switch
package main

import "fmt"

func main() {
    // 定义局部变量
    var mark string = "A"
    var score int = 80

    switch score {
    case 90:
        mark = "A"
    case 80:
        mark = "B"
    case 50, 60, 70:
        mark = "C"
    default:
        mark = "D"
    }

    switch {
    case mark == "A":
        fmt.Printf("good!\n")
    case mark == "B":
        fmt.Printf("just fun!\n")
    default:
        fmt.Printf("stupid!\n")
    }
    fmt.Printf("Your score is %s\n", score)
}
outcome:
just fun!
Your grade is B
  • switch还可用于判断变量类型
  • 各个case之间不需要break隔离,默认情况只执行一个case

nil

  • nil是go语言中预先的标识符。什么意思?就是可以直接使用nil,不需要提前声明,它可以代表指针,map,切片(slice),接口等类型的零值
  • 但是,但是,敲黑板了:仅仅只是声明,并没有赋值,在go语言中,如果声明一个变量并未对其赋值,那么这个变量就会有一个类型的默认零值
  • nil(safari):无,(数码)零;(比赛)0分
  • 看下边这个简单的栗子(伪代码):
// first
func main() {
    var a []int //声明但未赋值
    if a == nil {
        fmt.Println(1)
    } else {
        fmt.Println(0)
    }
}
ending:
1

// second
func main() {
    a := []int{} //声明并进行初始化,只不过内部为空
    if a == nil {
        fmt.Println(1)
    }else {
        fmt.Println(0)
    }
}
fructify:
0
  • 判断类型实例:
package main

import "fmt"

func main() {
    var a1 interface{}
    switch a2 = a1.(type) {
        case nil:
        fmt.Printf("a1's type is:%T",a2)
        case int:
        fmt.Printf("a1's type is int.")
        case float64:
        fmt.Printf("a1's type is float64.")
        case bool:
        fmt.Printf("a1's type is bool.")
        default:
        fmt.Printf("undefined!")
    }
}
result:
a1's type is:<nil>

fallthrough

  • 先上代码:
package main

import "fmt"

func main() {
    switch {
        case false:
        fmt.Println("00false")
        fallthrough
        case true:
        fmt.Println("01true")
        fallthrough
        case false:
        fmt.Println("02false")
        fallthrough
        case true:
        fmt.Println("03true")
        case false:
        fmt.Println("04false")
        fallthrough
        default:
        fmt.Println("05default")
    }
}
final result:
[Running] go run "d:\gowork\src\0928\test.go"
01true
02false
03true
[Done] exited with code=0 in 0.902 seconds
  • 解释来喽:首先代码执行会首先寻找第一个true语句进行执行,接下来会强制执行fallthrough后的case语句(fallthrough不会判断下个case是否为true),直到fallthrough消失,不知道大家懂了没,可以评论区讨论或者私信小鹿都可
  • fallthrough(safari):落空,(安排,计划,交易等)没有落实
  • default语句的位置是任意的:
package main

import "fmt"

func main() {
    a := 1
    switch {
    default:
        {
            fmt.Println("default")
        }
    case a > 10:
        {
            fmt.Println("a > 10")
        }
    case a < 10:
        {
            fmt.Println("a < 10")
        }
    }
}
result:
a < 10

循环语句

1.for循环

  • 先上代码结构(struct):
for init ; condition ; post {
    some code......
}
  • init:对变量进行初始化(可选)
  • condition:循环判断条件
  • post:控制变量的增减(可选)
  • 可以算一下1至5的和:
package main

import "fmt"

func main() {
    sum := 0
    for i := 0; i <= 5; i++ {
        sum += i
    }
    fmt.Println(sum)
}
15

2.range循环

  • 先看简单代码:
package main

import "fmt"

func main() {
    strings := []string{"c1", "c2", "c3", "c4", "c5"}
    for a1, b1 := range strings {
        fmt.Println(a1, b1)
    }
}
result:
0 c1
1 c2
2 c3
3 c4
4 c5
  • 稍微复杂一点的代码(其实一点也不复杂,换汤不换药):
func main() {
    array1 := [5]int{1, 2, 3}
    for x, y := range array1 {
        fmt.Println(x, y)
    }
}
result:
0 1
1 2
2 3
3 0
4 0
  • 也可以进行省略,先看代码:
package main

import "fmt"

func main() {
    myMap := make(map[int]float32)
    myMap[1] = 1.1
    myMap[2] = 1.2
    myMap[3] = 1.3
    for key, value := range myMap {
        fmt.Printf("key: %d --value:%f\n", key, value)
    }
}
ending:
key: 1 --value:1.100000
key: 2 --value:1.200000
key: 3 --value:1.300000
  • 下面是省略其中某一个:
for _, value := range myMap {
    fmt.Printf("value:%f\n", value)
}
for value := range myMap {
    fmt.Printf("value:%f\n", value)
}
ending:
value:1.100000
value:1.200000
value:1.300000
  • 循环嵌套(和C语言很像):
for {
    for {
        some code......
    }
}
有个问题:
双层嵌套循环的时间复杂度是多少?可以思考一下
  • break:用于跳出循环,并执行循环之后的语句
  • continue:很像break,但是它不是跳出循环,而是跳过当前循环,执行下一次循环
  • goto:这个关键字在Java有涉及到,go中的goto可以无条件转移到指定行,来实现条件转移,但一般不会用,会造成程序流程混乱,不利于开发人员调试,可以看一下下边的栗子:
package main

import "fmt"

func main() {
    // 定义局部变量
    a := 1
    // loop
loop:
    for a < 5 {
        if a == 2 {
            a += 1
            goto loop
        }
        fmt.Printf("a:%d\n", a)
        a++
    }
}
result:
a:1
a:3
a:4