Golang学习笔记_08—

Golang学习笔记_05——延迟调用
Golang学习笔记_06——变量和常量
Golang学习笔记_07——基本类型

文章目录

- For循环
- - 1. 基本形式
  - 2. 省略形式
  - 3. While循环
  - 4. 无限循环
  - 5. 使用 `range` 进行迭代
- 源码

For循环

在Go语言中，for 循环是唯一的一种循环结构，它非常灵活，可以用于实现传统的 for 循环、while 循环以及 do-while 循环。

1. 基本形式

Go 只有一种循环结构：for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：

初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行

初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式求值为 false，循环迭代就会终止。

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号，大括号 { } 则是必须的。

func basicDemo() {for i := 0; i < 10; i++ {fmt.Println("i = :", i)}
}

测试方法

func Test_basicDemo(t *testing.T) {basicDemo()
}

输出结果

=== RUN   Test_basicDemo
i = : 0
i = : 1
i = : 2
i = : 3
i = : 4
i = : 5
i = : 6
i = : 7
i = : 8
i = : 9
--- PASS: Test_basicDemo (0.00s)
PASS

2. 省略形式

在for循环的基础形式上，初始化语句和后置语句是可选的。

func omissionForDemo() {var i = 15for ; i > 2;  {fmt.Println("i = ", i)i %= 2}
}

测试方法

func Test_omissionForDemo(t *testing.T) {omissionForDemo()
}

输出结果

=== RUN   Test_omissionForDemo
i =  1
--- PASS: Test_omissionForDemo (0.00s)
PASS

3. While循环

如果省略初始化语句和后处理语句，for 循环将类似于传统的 while 循环

此时你可以去掉分号，因为 C 的 while 在 Go 中叫做 for。

func whileDemo() {var sum = 0for sum < 10 {sum += 1fmt.Println("sum = ", sum)}
}

测试方法

func Test_whileDemo(t *testing.T) {whileDemo()
}

输出结果

=== RUN   Test_whileDemo
sum =  1
sum =  2
sum =  3
sum =  4
sum =  5
sum =  6
sum =  7
sum =  8
sum =  9
sum =  10
--- PASS: Test_whileDemo (0.00s)
PASS

4. 无限循环

如果省略循环条件，for 循环将变成无限循环，类似于 do-while 循环（不过 do-while 是在循环体执行后才检查条件，而 Go 语言的无限循环需要手动控制退出）

func infiniteLoopDemo() {var sum = 100for {fmt.Println("sum = ", sum)sum -= 10if sum < 0 {break}}
}

测试方法

func Test_infiniteLoopDemo(t *testing.T) {infiniteLoopDemo()
}

输出结果

=== RUN   Test_infiniteLoopDemo
sum =  100
sum =  90
sum =  80
sum =  70
sum =  60
sum =  50
sum =  40
sum =  30
sum =  20
sum =  10
sum =  0
--- PASS: Test_infiniteLoopDemo (0.00s)
PASS

5. 使用 `range` 进行迭代

for 循环还可以与 range 关键字结合使用，用于迭代数组、切片、字符串、映射（map）和通道（channel）

func forRangeDemo() {nums := []int{1, 2, 3, 4, 5}for index, value := range nums {fmt.Printf("Index: %d, Value: %d\n", index, value)}// 迭代字符串str := "hello"for index, runeValue := range str {fmt.Printf("%#U starts at byte position %d\n", runeValue, index)}// 迭代mapm := map[string]int{"a": 1, "b": 2, "c": 3}for key, value := range m {fmt.Printf("Key: %s, Value: %d\n", key, value)}
}

测试方法

func Test_forRangeDemo(t *testing.T) {forRangeDemo()
}

输出结果

=== RUN   Test_forRangeDemo
Index: 0, Value: 1
Index: 1, Value: 2
Index: 2, Value: 3
Index: 3, Value: 4
Index: 4, Value: 5
U+0068 'h' starts at byte position 0
U+0065 'e' starts at byte position 1
U+006C 'l' starts at byte position 2
U+006C 'l' starts at byte position 3
U+006F 'o' starts at byte position 4
Key: a, Value: 1
Key: b, Value: 2
Key: c, Value: 3
--- PASS: Test_forRangeDemo (0.00s)
PASS

源码

// for_demo.go 文件package for_demoimport "fmt"func basicDemo() {for i := 0; i < 10; i++ {fmt.Println("i = :", i)}
}func omissionForDemo() {var i = 15for i > 2 {i %= 2fmt.Println("i = ", i)}
}func whileDemo() {var sum = 0for sum < 10 {sum += 1fmt.Println("sum = ", sum)}}func infiniteLoopDemo() {var sum = 100for {fmt.Println("sum = ", sum)sum -= 10if sum < 0 {break}}
}func forRangeDemo() {nums := []int{1, 2, 3, 4, 5}for index, value := range nums {fmt.Printf("Index: %d, Value: %d\n", index, value)}// 迭代字符串str := "hello"for index, runeValue := range str {fmt.Printf("%#U starts at byte position %d\n", runeValue, index)}// 迭代mapm := map[string]int{"a": 1, "b": 2, "c": 3}for key, value := range m {fmt.Printf("Key: %s, Value: %d\n", key, value)}
}

// for_demo_test.go 文件
package for_demoimport "testing"func Test_basicDemo(t *testing.T) {basicDemo()
}func Test_omissionForDemo(t *testing.T) {omissionForDemo()
}func Test_whileDemo(t *testing.T) {whileDemo()
}func Test_infiniteLoopDemo(t *testing.T) {infiniteLoopDemo()
}func Test_forRangeDemo(t *testing.T) {forRangeDemo()
}