Golang学习笔记_05------延迟调用
Golang学习笔记_06------变量和常量
Golang学习笔记_07------基本类型
文章目录
For循环
在Go语言中，for 循环是唯一的一种循环结构，它非常灵活，可以用于实现传统的 for 循环、while 循环以及 do-while 循环。
1. 基本形式
Go 只有一种循环结构：for 循环。
基本的 for 循环由三部分组成，它们用分号隔开：
- 初始化语句：在第一次迭代前执行
- 条件表达式：在每次迭代前求值
- 后置语句：在每次迭代的结尾执行
初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。
一旦条件表达式求值为 false，循环迭代就会终止。
注意 ：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号， 大括号 { } 则是必须的。
go
func basicDemo() {
for i := 0; i < 10; i++ {
fmt.Println("i = :", i)
}
}测试方法
go
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循环的基础形式上，初始化语句和后置语句是可选的。
go
func omissionForDemo() {
var i = 15
for ; i > 2; {
fmt.Println("i = ", i)
i %= 2
}
}测试方法
go
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。
go
func whileDemo() {
var sum = 0
for sum < 10 {
sum += 1
fmt.Println("sum = ", sum)
}
}测试方法
go
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 语言的无限循环需要手动控制退出）
go
func infiniteLoopDemo() {
var sum = 100
for {
fmt.Println("sum = ", sum)
sum -= 10
if sum < 0 {
break
}
}
}测试方法
go
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）
go
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)
}
// 迭代map
m := map[string]int{"a": 1, "b": 2, "c": 3}
for key, value := range m {
fmt.Printf("Key: %s, Value: %d\n", key, value)
}
}测试方法
go
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
源码
go
// for_demo.go 文件
package for_demo
import "fmt"
func basicDemo() {
for i := 0; i < 10; i++ {
fmt.Println("i = :", i)
}
}
func omissionForDemo() {
var i = 15
for i > 2 {
i %= 2
fmt.Println("i = ", i)
}
}
func whileDemo() {
var sum = 0
for sum < 10 {
sum += 1
fmt.Println("sum = ", sum)
}
}
func infiniteLoopDemo() {
var sum = 100
for {
fmt.Println("sum = ", sum)
sum -= 10
if 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)
}
// 迭代map
m := map[string]int{"a": 1, "b": 2, "c": 3}
for key, value := range m {
fmt.Printf("Key: %s, Value: %d\n", key, value)
}
}
go
// for_demo_test.go 文件
package for_demo
import "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()
}