Golang 控制结构

package main

import "fmt"

// 控制结构
func main(){

    // if 语句
    // Go 中的 if 语句用于执行条件判断，语法与大多数编程语言类似，但 Go 的 if 语句没有括号，条件表达式直接放在 if 后面

    // if condition {
    //  // 条件为真时执行的代码
    // }
    x := 10

    if x == 10 {
        fmt.Println("x = 10")
    }

    // if else 语句
    // if condition {
    //  // 条件为真时执行的代码
    // } else {
    //  // 条件为假时执行的代码
    // }
    if x > 10 {
        fmt.Println("x > 10")
    } else {
        fmt.Println("x <= 10")
    }

    // if-else if-else 语句
    // 可以使用多个 else if 来处理多条件判断。
    if x == 1 {
        fmt.Println("x = 1")
    } else if x == 2 {
        fmt.Println("x = 2")
    } else if x == 3 {
        fmt.Println("x = 3")
    } else {
        fmt.Println("x != 1 && x != 2 && x != 3")
    }

    // if条件语句中的短声明
    // Go 的 if 语句支持在条件中声明和初始化变量，这在条件语句中很常见

    if testa := 10; testa > 0 {
        fmt.Println("testa > 0",testa)
    }
    //这里的 testa 只在 if 语句块内有效。
    //fmt.Println("testa",testa) // 此处使用testa将会报错

    // for循环
    // Go 中唯一的循环结构是 for。它可以用来实现各种类型的循环（类似于 C 语言的 for、while、do-while）

    // for initialization; condition; post {
    //  // 循环体
    // }
    // initialization：在循环开始时执行的代码，通常用于初始化循环变量。
    // condition：每次循环前检查的条件，如果为真则执行循环体。
    // post：每次循环结束时执行的代码，通常用于更新循环变量。
    for ia := 0;ia < 10; ia++ {
        fmt.Println("ia:",ia)
    }

    // 模拟while循环
    ib := 0
    for ib < 5 {
        fmt.Println("ib:",ib)
        ib++
    }

    // 无限循环
    // Go 的 for 语句也可以作为无限循环使用，只需要省略条件部分
    // for {
    //  //无限循环
    //  fmt.Println("无限循环")
    // }

    // switch语句
    // 是另一种控制结构，用于在多个条件中选择一个执行。Go 中的 switch 更加简洁和灵活，支持自动“fallthrough”行为，也支持条件判断和多条件匹配。
    // switch value {
    // case condition1:
    //  // 执行代码
    // case condition2:
    //  // 执行代码
    // default:
    //  // 如果没有匹配的条件，执行 default 中的代码
    // }

    day := 4
    switch day {
    case 1:
        fmt.Println("day = 1")
    case 2:
        fmt.Println("day = 2")
    case 3:
        fmt.Println("day = 3")
    default:
        fmt.Println("day != 1 && day !=2 && day != 3")
    }

    // 没有条件的switch语句
    // 如果没有 value，switch 会自动判断每个 case 的条件，直到遇到第一个满足的条件为止。
    switch {
    case day < 10:
        fmt.Println("day is less than 10")
    case day == 10:
        fmt.Println("day is equal to 10")
    default:
        fmt.Println("day is greater than 10")
    }

    // fallthrough 关键字
    // 在 Go 中，switch 不会自动执行下一个 case，除非显式使用 fallthrough 关键字
    x = 1
    switch x {
    case 1:
        fmt.Println("One") // 会输出
        fallthrough
    case 2:
        fmt.Println("Two") // 会输出
        fallthrough
    case 3:
        fmt.Println("Three") // 会输出
    case 4:
        fmt.Println("Four") // 不会输出
    }

    var nx interface{}
    nx = 1
    // switch语句中的类型匹配
    // Go 支持在 switch 中进行类型匹配，可以根据类型来分支
    switch v := nx.(type) { // 类型断言
    case int:
        fmt.Println("nx is of type int:", v)
    case string:
        fmt.Println("nx is of type string:", v)
    default:
        fmt.Println("Unknown type")
    }

    // select 语句
    // select 语句用于处理多个通道的操作，它是 Go 中用于并发编程的一个关键控制结构。select 会等待多个通道中的操作完成，并选择一个进行处理

    // select {
    // case <-chan1:
    //  // chan1 收到数据时执行
    // case <-chan2:
    //  // chan2 收到数据时执行
    // default:
    //  // 如果没有通道准备好，则执行 default
    // }

    // package main

    // import "fmt"

    // func main() {
    //  ch1 := make(chan string)
    //  ch2 := make(chan string)

    //  go func() {
    //      ch1 <- "Hello from ch1"
    //  }()
    //  go func() {
    //      ch2 <- "Hello from ch2"
    //  }()

    //  select {
    //  case msg1 := <-ch1:
    //      fmt.Println(msg1)
    //  case msg2 := <-ch2:
    //      fmt.Println(msg2)
    //  }
    // }

    // select 语句中的default关键字
    // 如果所有的通道都没有准备好，default 分支将会执行

    //总结
    // if 语句：用于条件判断，支持 else 和 else if。
    // for 循环：唯一的循环结构，支持多种形式的循环，包括传统的 for 循环、while 循环和无限循环。
    // switch 语句：用于选择多个条件之一，支持多条件匹配、类型断言和 fallthrough。
    // select 语句：用于并发编程，处理多个通道的读取和写入操作。

}