一、Go基础知识9、条件判断与循环

风不归Alkaid

已于 2023-11-23 17:26:33 修改

阅读量400

点赞数 20

分类专栏： Go的小细节文章标签： golang 开发语言后端

于 2023-11-23 17:14:44 首次发布

本文链接：https://blog.csdn.net/weixin_49015143/article/details/134581565

版权

Go的小细节专栏收录该内容

44 篇文章 3 订阅

订阅专栏

一、条件判断

1、基本的if语句

package main

import "fmt"

func main() {
    x := 10

    if x > 5 {
        fmt.Println("x大于5")
    }
}

结果：

x大于5

2、带有else的if语句

package main

import "fmt"

func main() {
    x := 3

    if x > 5 {
        fmt.Println("x大于5")
    } else {
        fmt.Println("x不大于5")
    }
}

结果：

x不大于5

3、多个条件判断

package main

import "fmt"

func main() {
    x := 7

    if x > 10 {
        fmt.Println("x大于10")
    } else if x > 5 {
        fmt.Println("x大于5且小于等于10")
    } else {
        fmt.Println("x小于等于5")
    }
}

结果：

x大于5且小于等于10

4、Switch语句

package main

import "fmt"

func main() {
    day := "Monday"

    switch day {
    case "Monday":
        fmt.Println("星期一")
    case "Tuesday":
        fmt.Println("星期二")
    default:
        fmt.Println("其他天")
    }
}

结果：

星期一

5、Type Switch

package main

import "fmt"

func checkType(x interface{}) {
    switch x.(type) {
    case int:
        fmt.Println("x是一个整数")
    case string:
        fmt.Println("x是一个字符串")
    default:
        fmt.Println("未知类型")
    }
}

func main() {
    checkType(42)
    checkType("Hello")
    checkType(3.14)
}

结果：

x是一个整数
x是一个字符串
未知类型

二、for循环的用法

1、基本的for循环

package main

import "fmt"

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

结果：

2、无限循环

package main

import "fmt"

func main() {
    i := 0
    for {
        fmt.Println(i)
        i++
        if i == 5 {
            break
        }
    }
}

结果：

3、使用`range`迭代数组或切片

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    for index, value := range numbers {
        fmt.Printf("索引：%d, 值：%d\n", index, value)
    }
}

结果：

索引：0, 值：1
索引：1, 值：2
索引：2, 值：3
索引：3, 值：4
索引：4, 值：5

4、使用`range`迭代map

package main

import "fmt"

func main() {
    myMap := map[string]int{"a": 1, "b": 2, "c": 3}

    for key, value := range myMap {
        fmt.Printf("键：%s, 值：%d\n", key, value)
    }
}

结果：

键：a, 值：1
键：b, 值：2
键：c, 值：3

5、使用`for`实现while循环

package main

import "fmt"

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

结果：

三、for range的用法

1、迭代数组或切片

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    for index, value := range numbers {
        fmt.Printf("索引：%d, 值：%d\n", index, value)
    }
}

结果：

索引：0, 值：1
索引：1, 值：2
索引：2, 值：3
索引：3, 值：4
索引：4, 值：5

2、迭代字符串

package main

import "fmt"

func main() {
    text := "Hello, Go!"

    for index, char := range text {
        fmt.Printf("索引：%d, 字符：%c\n", index, char)
    }
}

结果：

索引：0, 字符：H
索引：1, 字符：e
索引：2, 字符：l
索引：3, 字符：l
索引：4, 字符：o
索引：5, 字符：,
索引：6, 字符： 
索引：7, 字符：G
索引：8, 字符：o
索引：9, 字符：!

3、迭代map

package main

import "fmt"

func main() {
    myMap := map[string]int{"a": 1, "b": 2, "c": 3}

    for key, value := range myMap {
        fmt.Printf("键：%s, 值：%d\n", key, value)
    }
}

结果：

键：a, 值：1
键：b, 值：2
键：c, 值：3

4、仅迭代值或索引

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    // 仅迭代值
    for _, value := range numbers {
        fmt.Printf("值：%d\n", value)
    }

    // 仅迭代索引
    for index := range numbers {
        fmt.Printf("索引：%d\n", index)
    }
}

结果：

值：1
值：2
值：3
值：4
值：5
索引：0
索引：1
索引：2
索引：3
索引：4

四、break与continue

在Go语言中，break和continue是用于控制循环流程的关键字。

1、break语句

break语句用于立即结束循环，无论循环条件是否为真。它会跳出当前的for、switch或select语句，执行循环外的下一条语句。

示例：

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        if i == 3 {
            break
        }
        fmt.Println(i)
    }
}

结果：

0
1
2

解释：
在这个例子中，当i的值等于3时，break语句被执行，导致循环立即结束。

2、continue语句

continue语句用于跳过循环体内剩余的代码，直接进入下一次循环的迭代。它终止当前迭代，但不会结束整个循环。

示例：

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        if i == 2 {
            continue
        }
        fmt.Println(i)
    }
}

结果：

解释：
在这个例子中，当i的值等于2时，continue语句被执行，导致循环体内剩余的代码不再执行，直接进入下一次循环。

五、Switch语句详解

Go语言中的switch语句用于处理多个条件的情况。

基本的`switch`语法

switch expression {
case value1:
    // 当expression等于value1时执行的代码
case value2:
    // 当expression等于value2时执行的代码
case value3:
    // 当expression等于value3时执行的代码
default:
    // 当expression不等于任何case时执行的代码
}

expression是一个要被比较的表达式。
case后面跟着一个期望的值。
如果expression等于某个case后面的值，那么与该case相关的代码块将被执行。
如果没有一个case的值与expression匹配，并且存在default语句，那么将执行default语句。

1、基本的`switch`语句

package main

import "fmt"

func main() {
    day := 3

    switch day {
    case 1:
        fmt.Println("星期一")
    case 2:
        fmt.Println("星期二")
    case 3:
        fmt.Println("星期三")
    case 4:
        fmt.Println("星期四")
    case 5:
        fmt.Println("星期五")
    default:
        fmt.Println("周末")
    }
}

结果：

星期三

解释：
在这个例子中，day的值为3，与case 3匹配，因此执行与之关联的代码块。

2、`switch`中使用多个值

package main

import "fmt"

func main() {
    day := 6

    switch day {
    case 1, 2, 3, 4, 5:
        fmt.Println("工作日")
    case 6, 7:
        fmt.Println("周末")
    default:
        fmt.Println("无效的日期")
    }
}

结果：

周末

解释：
在这个例子中，day的值为6，与case 6, 7匹配，因此执行与之关联的代码块。

3、`switch`中使用表达式

package main

import "fmt"

func main() {
    num := 42

    switch {
    case num < 0:
        fmt.Println("负数")
    case num == 0:
        fmt.Println("零")
    case num > 0:
        fmt.Println("正数")
    }
}

结果：

正数

解释：
在这个例子中，switch没有表达式，相当于switch true。当num > 0为真时，执行与之关联的代码块。

六、goto语句详解

在Go语言中，goto语句用于无条件地转移到程序中的某个标签（label）处。
goto语句通常被认为是一种不鼓励使用的控制流结构，因为它可能导致代码变得难以理解和维护。然而，在一些特殊情况下，使用goto语句可能是一种有效的解决方案。

`goto`语法

goto label
// ...
label:
// 这里是标签处的代码

goto语句后面跟着一个标签的名称。
标签的名称后面跟着一个冒号（:）。
标签必须在同一函数内，且不能在代码块内声明。

示例

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        if i == 3 {
            goto End
        }
        fmt.Println(i)
    }

End:
    fmt.Println("循环结束")
}