GO_基础2

一、控制语句

  • 条件语句

if语句、if ... else 语句， if嵌套语句、if...else...if语句、

  • 循环语句

    • 简单for循环

    • for作为无限循环

    • for作为while循环

    • for循环中的简单范围

      • i和j是分配迭代值的变量。它们也称为迭代变量。

      • 第二个变量，即j是可选的。

      • 范围表达式在循环开始之前被评估一次。

      • 复制代码
        package main 
import "fmt"
func main() { 
      
    //这里rvariable是一个数组 
    rvariable:= []string{"GFG", "Geeks", "cainiaojc"}  
      
        //i和j存储rvariable的值
        //i存储单个字符串和的索引号
        //j存储给定数组的单个字符串
    for i, j:= range rvariable { 
       fmt.Println(i, j)  
    } 
    
}
        
输出：
0 GFG
1 Geeks
2 cainiaojc
        复制代码

    • 字符串中的for

for循环可以遍历字符串的Unicode代码点。

在这里，索引是存储UTF-8编码代码点的第一个字节的变量，而chr是存储给定字符串的字符的变量，而str是字符串。

      • 复制代码
        示例
package main
import "fmt"
func main() {

    // 字符串作为for循环中的范围
    for i, j := range "XabCd" {
        fmt.Printf("%U 的索引值为 %d\n", j, i)
    }

}

        输出：

        U+0058 的索引值为 0
U+0061 的索引值为 1
U+0062 的索引值为 2
U+0043 的索引值为 3
U+0064 的索引值为 4
        复制代码

    • 对于map使用for循环

for循环可以遍历map的键和值对。

      • 复制代码
        示例
package main
import "fmt"
func main() {

    mmap := map[int]string{
        22: "Geeks",
        33: "GFG",
        44: "cainiaojc",
    }
    for key, value := range mmap {
        fmt.Println(key, value)
    }
}
输出：

22 Geeks
33 GFG
44 cainiaojc
        复制代码

    • For通道：

 for循环可以遍历通道上发送的顺序值，直到关闭为止。

      • 复制代码
示例
package main
import "fmt"
func main() {

    // 使用 channel
    chnl := make(chan int)
    go func() {
        chnl <- 100
        chnl <- 1000
        chnl <- 10000
        chnl <- 100000
        close(chnl)
    }()
    for i := range chnl {
        fmt.Println(i)
    }

}
输出：

100
1000
10000
100000

         

    • 重要事项：

      • 在for循环的三个语句中不使用括号。

      • 花括号在for循环中是必需的。

      • 左括号应与post语句所在的行相同。

      • 如果数组，字符串，切片或map集合为空，则for循环不会抛出错误并继续其流程。换句话说，如果数组，字符串，切片或map为nil，则for循环的迭代次数为零。

  • 循环控制语句

    • Go语言支持3种循环控制语句：

      • Break

      • Continue

      • Goto

    • 该语句用于将控制转移到程序中的标记语句。标签是有效的标识符，放在控件转移处的语句前面。由于难以跟踪程序的控制流，程序员通常不使用goto语句。

      • package main  
import "fmt"
func main() { 
   var x int = 0 
     
   //for循环的工作原理与while循环相同
  Lable1: for x < 8 { 
      if x == 5 { 
           
         //使用goto语句
         x = x + 1; 
         goto Lable1 
      } 
      fmt.Printf("值为: %d\n", x); 
      x++;      
   }   
}
输出：

值为: 0
值为: 1
值为: 2
值为: 3
值为: 4
值为: 6
值为

  • switch语句

      • Go语言支持两种类型的switch语句:

        • 表达式switch

          • switch optstatement; optexpression{
    case expression1: Statement..
    case expression2: Statement..
    ...
    default: Statement..
}
          • package main
import "fmt"
func main() {

    // Switch 语句同时使用两种语句, 如可选语句, day:=4 和表达式 如：day
    switch day := 4; day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    case 6:
        fmt.Println("Saturday")
    case 7:
        fmt.Println("Sunday")
    default:
        fmt.Println("Invalid")
    }
}

            输出：

            Thursday
      • switch语句不带可选语句和表达式的示例： 
        • package main 
import "fmt"
func main() { 
    var value int = 2 
      
      // switch语句不带可选语句和表达式
   switch { 
       case value == 1: 
       fmt.Println("Hello") 
       case value == 2: 
       fmt.Println("Bonjour") 
       case value == 3: 
       fmt.Println("Namstay") 
       default:  
       fmt.Println("Invalid") 
   }  
}
输出：
Bonjour
      • 没有默认语句的switch语句，case语句中的多个值： 
        • package main
import "fmt"
func main() {
    var value string = "five"

    //没有默认语句的switch语句，case语句中的多个值
    switch value {
    case "one":
        fmt.Println("C#")
    case "two", "three":
        fmt.Println("Go")
    case "four", "five", "six":
        fmt.Println("Java")
    }
}
输出：
Java

      • 类型switch

        • 语法：

          switch optstatement; typeswitchexpression{
    case typelist 1: Statement..
    case typelist 2: Statement..
    ...
    default: Statement..
}
          package main
import "fmt"
func main() {
    var value interface{}
    switch q := value.(type) {
    case bool:
        fmt.Println("值是布尔型")
    case float64:
        fmt.Println("值是float64类型")
    case int:
        fmt.Println("值是int类型")
    default:
        fmt.Printf("值的类型是: %T", q)
    }
}
输出：
值的类型是: <nil>

    • select 和 deadlock死锁

      • 在Go语言中，select语句就像switch语句，但是在select语句中，case语句引用通信，即通道上的发送或接收操作。

        在本文中，我们将学习如何使用默认情况来避免死锁。但是首先，我们了解什么是deadlock？

        • 死锁：当您试图从通道读取或写入数据但通道没有值时。因此，它阻塞goroutine的当前执行，并将控制传递给其他goroutine，但是如果没有其他goroutine可用或其他goroutine睡眠，由于这种情况，程序将崩溃。这种现象称为死锁。如下面的实例所示：
        • 示例
package main

func main() {

    //创建通道
    //出现死锁是因为没有goroutine在写
    //因此，select语句被永远阻塞
    c := make(chan int)
    select {
    case <-c:
    }
}
输出：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
        • 为了避免这种情况，我们在select语句中使用默认case。换句话说，当程序中出现死锁时，将执行select语句的默认情况以避免死锁。如下例所示，我们在select语句中使用默认情况以避免死锁。
          • 示例
package main 
  
import "fmt"
  
func main() { 
  
    //创建通道
    c := make(chan int) 
    select { 
    case <-c: 
    default: 
        fmt.Println("!.. Default case..!") 
    } 
}
输出：

!.. Default case..!
        • 当select语句只有nil通道时，也允许使用默认情况。如下面的实例所示，通道c是nil，所以默认情况下执行，如果这里的默认情况是不可用的，那么程序将永远被阻塞，死锁出现。 
          • 示例
package main

import "fmt"

func main() {

    //创建通道
    var c chan int

    select {
    case x1 := <-c:
        fmt.Println("Value: ", x1)
    default:
        fmt.Println("Default case..!")
    }
}
输出：

Default case..!
    •  
posted @ 2025-10-07 22:40  直至成伤  阅读(10)  评论(0)    收藏  举报