698 lines
16 KiB
Go
698 lines
16 KiB
Go
/*
|
||
04-range.go - Go 语言 range 关键字详解
|
||
|
||
学习目标：
|
||
1. 掌握 range 的基本用法
|
||
2. 理解 range 在不同数据类型上的应用
|
||
3. 学会处理 range 返回的索引和值
|
||
4. 了解 range 的性能特点
|
||
5. 掌握 range 的实际应用场景
|
||
|
||
知识点：
|
||
- range 遍历数组和切片
|
||
- range 遍历字符串
|
||
- range 遍历映射 (map)
|
||
- range 遍历通道 (channel)
|
||
- range 的值拷贝特性
|
||
- 忽略索引或值的技巧
|
||
- range 的性能考虑
|
||
*/
|
||
|
||
package main
|
||
|
||
import (
|
||
"fmt"
|
||
"unicode/utf8"
|
||
)
|
||
|
||
func main() {
|
||
fmt.Println("=== Go 语言 range 关键字详解 ===\n")
|
||
|
||
// 演示 range 遍历数组和切片
|
||
demonstrateRangeArraySlice()
|
||
|
||
// 演示 range 遍历字符串
|
||
demonstrateRangeString()
|
||
|
||
// 演示 range 遍历映射
|
||
demonstrateRangeMap()
|
||
|
||
// 演示 range 遍历通道
|
||
demonstrateRangeChannel()
|
||
|
||
// 演示 range 的值拷贝特性
|
||
demonstrateRangeValueCopy()
|
||
|
||
// 演示忽略索引或值
|
||
demonstrateIgnoreIndexValue()
|
||
|
||
// 演示 range 的实际应用
|
||
demonstratePracticalExamples()
|
||
|
||
// 演示 range 的性能考虑
|
||
demonstratePerformanceConsiderations()
|
||
}
|
||
|
||
// demonstrateRangeArraySlice 演示 range 遍历数组和切片
|
||
func demonstrateRangeArraySlice() {
|
||
fmt.Println("1. range 遍历数组和切片:")
|
||
|
||
// 遍历数组
|
||
fmt.Printf(" 遍历数组:\n")
|
||
arr := [5]int{10, 20, 30, 40, 50}
|
||
|
||
for index, value := range arr {
|
||
fmt.Printf(" arr[%d] = %d\n", index, value)
|
||
}
|
||
|
||
// 遍历切片
|
||
fmt.Printf(" 遍历切片:\n")
|
||
slice := []string{"Go", "Python", "Java", "JavaScript"}
|
||
|
||
for i, lang := range slice {
|
||
fmt.Printf(" 语言 %d: %s\n", i+1, lang)
|
||
}
|
||
|
||
// 遍历空切片
|
||
fmt.Printf(" 遍历空切片:\n")
|
||
var emptySlice []int
|
||
count := 0
|
||
for range emptySlice {
|
||
count++
|
||
}
|
||
fmt.Printf(" 空切片遍历次数: %d\n", count)
|
||
|
||
// 遍历 nil 切片
|
||
fmt.Printf(" 遍历 nil 切片:\n")
|
||
var nilSlice []int = nil
|
||
count = 0
|
||
for range nilSlice {
|
||
count++
|
||
}
|
||
fmt.Printf(" nil 切片遍历次数: %d\n", count)
|
||
|
||
// 多维切片遍历
|
||
fmt.Printf(" 遍历二维切片:\n")
|
||
matrix := [][]int{
|
||
{1, 2, 3},
|
||
{4, 5, 6},
|
||
{7, 8, 9},
|
||
}
|
||
|
||
for i, row := range matrix {
|
||
for j, value := range row {
|
||
fmt.Printf(" matrix[%d][%d] = %d\n", i, j, value)
|
||
}
|
||
}
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateRangeString 演示 range 遍历字符串
|
||
func demonstrateRangeString() {
|
||
fmt.Println("2. range 遍历字符串:")
|
||
|
||
// 基本字符串遍历
|
||
fmt.Printf(" 遍历 ASCII 字符串:\n")
|
||
str1 := "Hello"
|
||
|
||
for index, char := range str1 {
|
||
fmt.Printf(" str1[%d] = '%c' (Unicode: %d)\n", index, char, char)
|
||
}
|
||
|
||
// 遍历包含中文的字符串
|
||
fmt.Printf(" 遍历包含中文的字符串:\n")
|
||
str2 := "Hello世界"
|
||
|
||
for index, char := range str2 {
|
||
fmt.Printf(" 位置 %d: '%c' (Unicode: %d)\n", index, char, char)
|
||
}
|
||
|
||
// 注意：index 是字节位置，不是字符位置
|
||
fmt.Printf(" 注意: range 返回的索引是字节位置，不是字符位置\n")
|
||
|
||
// 字符串长度对比
|
||
fmt.Printf(" 字符串长度对比:\n")
|
||
fmt.Printf(" 字节长度 len(\"%s\"): %d\n", str2, len(str2))
|
||
fmt.Printf(" 字符长度 utf8.RuneCountInString(\"%s\"): %d\n",
|
||
str2, utf8.RuneCountInString(str2))
|
||
|
||
// 遍历字符串的字节
|
||
fmt.Printf(" 按字节遍历字符串:\n")
|
||
for i := 0; i < len(str2); i++ {
|
||
fmt.Printf(" 字节 %d: %d ('%c')\n", i, str2[i], str2[i])
|
||
if i >= 7 { // 限制输出
|
||
fmt.Printf(" ...\n")
|
||
break
|
||
}
|
||
}
|
||
|
||
// 统计字符类型
|
||
fmt.Printf(" 统计字符类型:\n")
|
||
text := "Hello, 世界! 123"
|
||
ascii, unicode, digit, other := 0, 0, 0, 0
|
||
|
||
for _, char := range text {
|
||
switch {
|
||
case char >= 'A' && char <= 'Z' || char >= 'a' && char <= 'z':
|
||
ascii++
|
||
case char >= '0' && char <= '9':
|
||
digit++
|
||
case char > 127:
|
||
unicode++
|
||
default:
|
||
other++
|
||
}
|
||
}
|
||
|
||
fmt.Printf(" 文本: \"%s\"\n", text)
|
||
fmt.Printf(" ASCII字母: %d, Unicode字符: %d, 数字: %d, 其他: %d\n",
|
||
ascii, unicode, digit, other)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateRangeMap 演示 range 遍历映射
|
||
func demonstrateRangeMap() {
|
||
fmt.Println("3. range 遍历映射 (map):")
|
||
|
||
// 基本映射遍历
|
||
fmt.Printf(" 遍历基本映射:\n")
|
||
scores := map[string]int{
|
||
"Alice": 95,
|
||
"Bob": 87,
|
||
"Charlie": 92,
|
||
"David": 78,
|
||
}
|
||
|
||
for name, score := range scores {
|
||
fmt.Printf(" %s: %d分\n", name, score)
|
||
}
|
||
|
||
// 注意：映射遍历顺序是随机的
|
||
fmt.Printf(" 注意: 映射的遍历顺序是随机的\n")
|
||
|
||
// 遍历复杂映射
|
||
fmt.Printf(" 遍历复杂映射:\n")
|
||
students := map[string]map[string]interface{}{
|
||
"student1": {
|
||
"name": "张三",
|
||
"age": 20,
|
||
"grade": "A",
|
||
},
|
||
"student2": {
|
||
"name": "李四",
|
||
"age": 21,
|
||
"grade": "B",
|
||
},
|
||
}
|
||
|
||
for id, info := range students {
|
||
fmt.Printf(" 学生ID: %s\n", id)
|
||
for key, value := range info {
|
||
fmt.Printf(" %s: %v\n", key, value)
|
||
}
|
||
}
|
||
|
||
// 统计映射信息
|
||
fmt.Printf(" 统计映射信息:\n")
|
||
wordCount := map[string]int{
|
||
"go": 10,
|
||
"python": 8,
|
||
"java": 15,
|
||
"rust": 5,
|
||
}
|
||
|
||
totalWords := 0
|
||
maxCount := 0
|
||
mostPopular := ""
|
||
|
||
for word, count := range wordCount {
|
||
totalWords += count
|
||
if count > maxCount {
|
||
maxCount = count
|
||
mostPopular = word
|
||
}
|
||
}
|
||
|
||
fmt.Printf(" 词汇统计: %v\n", wordCount)
|
||
fmt.Printf(" 总词数: %d\n", totalWords)
|
||
fmt.Printf(" 最受欢迎的词: %s (%d次)\n", mostPopular, maxCount)
|
||
|
||
// 遍历空映射
|
||
fmt.Printf(" 遍历空映射:\n")
|
||
emptyMap := make(map[string]int)
|
||
count := 0
|
||
for range emptyMap {
|
||
count++
|
||
}
|
||
fmt.Printf(" 空映射遍历次数: %d\n", count)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateRangeChannel 演示 range 遍历通道
|
||
func demonstrateRangeChannel() {
|
||
fmt.Println("4. range 遍历通道 (channel):")
|
||
|
||
fmt.Printf(" 基本通道遍历:\n")
|
||
|
||
// 创建一个通道并发送数据
|
||
ch := make(chan int, 5)
|
||
|
||
// 发送数据到通道
|
||
for i := 1; i <= 5; i++ {
|
||
ch <- i * 10
|
||
}
|
||
close(ch) // 关闭通道，range 才能正常结束
|
||
|
||
// 使用 range 遍历通道
|
||
for value := range ch {
|
||
fmt.Printf(" 从通道接收: %d\n", value)
|
||
}
|
||
|
||
// 字符串通道示例
|
||
fmt.Printf(" 字符串通道遍历:\n")
|
||
strCh := make(chan string, 3)
|
||
|
||
messages := []string{"Hello", "World", "Go"}
|
||
for _, msg := range messages {
|
||
strCh <- msg
|
||
}
|
||
close(strCh)
|
||
|
||
for message := range strCh {
|
||
fmt.Printf(" 消息: %s\n", message)
|
||
}
|
||
|
||
// 注意：如果通道没有关闭，range 会一直等待
|
||
fmt.Printf(" 注意: 通道必须关闭，否则 range 会一直等待\n")
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateRangeValueCopy 演示 range 的值拷贝特性
|
||
func demonstrateRangeValueCopy() {
|
||
fmt.Println("5. range 的值拷贝特性:")
|
||
|
||
fmt.Printf(" range 会拷贝值，修改拷贝不会影响原始数据:\n")
|
||
|
||
// 结构体切片示例
|
||
type Person struct {
|
||
Name string
|
||
Age int
|
||
}
|
||
|
||
people := []Person{
|
||
{"Alice", 25},
|
||
{"Bob", 30},
|
||
{"Charlie", 35},
|
||
}
|
||
|
||
fmt.Printf(" 原始数据:\n")
|
||
for i, person := range people {
|
||
fmt.Printf(" people[%d]: %+v\n", i, person)
|
||
}
|
||
|
||
// 尝试修改 range 返回的值（不会影响原始数据）
|
||
fmt.Printf(" 尝试修改 range 返回的值:\n")
|
||
for i, person := range people {
|
||
person.Age += 10 // 这不会修改原始数据
|
||
fmt.Printf(" 修改后的拷贝 people[%d]: %+v\n", i, person)
|
||
}
|
||
|
||
fmt.Printf(" 原始数据（未改变）:\n")
|
||
for i, person := range people {
|
||
fmt.Printf(" people[%d]: %+v\n", i, person)
|
||
}
|
||
|
||
// 正确的修改方式：使用索引
|
||
fmt.Printf(" 正确的修改方式（使用索引）:\n")
|
||
for i := range people {
|
||
people[i].Age += 5
|
||
}
|
||
|
||
for i, person := range people {
|
||
fmt.Printf(" people[%d]: %+v\n", i, person)
|
||
}
|
||
|
||
// 指针切片的情况
|
||
fmt.Printf(" 指针切片的情况:\n")
|
||
ptrPeople := []*Person{
|
||
{"David", 28},
|
||
{"Eve", 32},
|
||
}
|
||
|
||
// 通过指针修改（会影响原始数据）
|
||
for _, personPtr := range ptrPeople {
|
||
personPtr.Age += 2
|
||
}
|
||
|
||
for i, personPtr := range ptrPeople {
|
||
fmt.Printf(" ptrPeople[%d]: %+v\n", i, *personPtr)
|
||
}
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateIgnoreIndexValue 演示忽略索引或值
|
||
func demonstrateIgnoreIndexValue() {
|
||
fmt.Println("6. 忽略索引或值:")
|
||
|
||
// 只需要值，忽略索引
|
||
fmt.Printf(" 只需要值，忽略索引（使用 _ ）:\n")
|
||
numbers := []int{1, 4, 9, 16, 25}
|
||
sum := 0
|
||
|
||
for _, value := range numbers {
|
||
sum += value
|
||
}
|
||
fmt.Printf(" 数组 %v 的和: %d\n", numbers, sum)
|
||
|
||
// 只需要索引，忽略值
|
||
fmt.Printf(" 只需要索引，忽略值:\n")
|
||
items := []string{"apple", "banana", "cherry", "date"}
|
||
|
||
for index := range items {
|
||
fmt.Printf(" 索引 %d\n", index)
|
||
}
|
||
|
||
// 既不需要索引也不需要值（只是计数）
|
||
fmt.Printf(" 只计算元素个数:\n")
|
||
data := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
|
||
count := 0
|
||
|
||
for range data {
|
||
count++
|
||
}
|
||
fmt.Printf(" 元素个数: %d\n", count)
|
||
|
||
// 映射中忽略键或值
|
||
fmt.Printf(" 映射中忽略键或值:\n")
|
||
grades := map[string]int{
|
||
"Math": 90,
|
||
"English": 85,
|
||
"Science": 92,
|
||
}
|
||
|
||
// 只要值
|
||
fmt.Printf(" 所有分数: ")
|
||
for _, score := range grades {
|
||
fmt.Printf("%d ", score)
|
||
}
|
||
fmt.Printf("\n")
|
||
|
||
// 只要键
|
||
fmt.Printf(" 所有科目: ")
|
||
for subject := range grades {
|
||
fmt.Printf("%s ", subject)
|
||
}
|
||
fmt.Printf("\n")
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePracticalExamples 演示 range 的实际应用
|
||
func demonstratePracticalExamples() {
|
||
fmt.Println("7. range 的实际应用:")
|
||
|
||
// 示例1: 数据统计
|
||
fmt.Printf(" 示例1 - 销售数据统计:\n")
|
||
sales := map[string][]int{
|
||
"Q1": {100, 120, 110, 130},
|
||
"Q2": {140, 135, 150, 145},
|
||
"Q3": {160, 155, 170, 165},
|
||
"Q4": {180, 175, 190, 185},
|
||
}
|
||
|
||
yearTotal := 0
|
||
for quarter, monthlySales := range sales {
|
||
quarterTotal := 0
|
||
for _, monthSale := range monthlySales {
|
||
quarterTotal += monthSale
|
||
}
|
||
yearTotal += quarterTotal
|
||
fmt.Printf(" %s 季度总销售额: %d\n", quarter, quarterTotal)
|
||
}
|
||
fmt.Printf(" 全年总销售额: %d\n", yearTotal)
|
||
|
||
// 示例2: 配置文件处理
|
||
fmt.Printf(" 示例2 - 配置文件处理:\n")
|
||
config := map[string]interface{}{
|
||
"server_port": 8080,
|
||
"debug_mode": true,
|
||
"database_url": "localhost:5432",
|
||
"max_connections": 100,
|
||
"timeout": 30.5,
|
||
}
|
||
|
||
for key, value := range config {
|
||
fmt.Printf(" 配置项 %s: ", key)
|
||
switch v := value.(type) {
|
||
case int:
|
||
fmt.Printf("%d (整数)\n", v)
|
||
case bool:
|
||
fmt.Printf("%t (布尔值)\n", v)
|
||
case string:
|
||
fmt.Printf("\"%s\" (字符串)\n", v)
|
||
case float64:
|
||
fmt.Printf("%.1f (浮点数)\n", v)
|
||
default:
|
||
fmt.Printf("%v (未知类型)\n", v)
|
||
}
|
||
}
|
||
|
||
// 示例3: 文本处理
|
||
fmt.Printf(" 示例3 - 单词频率统计:\n")
|
||
text := "go is great go is simple go is fast"
|
||
words := []string{"go", "is", "great", "go", "is", "simple", "go", "is", "fast"}
|
||
|
||
wordFreq := make(map[string]int)
|
||
for _, word := range words {
|
||
wordFreq[word]++
|
||
}
|
||
|
||
fmt.Printf(" 文本: \"%s\"\n", text)
|
||
fmt.Printf(" 词频统计:\n")
|
||
for word, freq := range wordFreq {
|
||
fmt.Printf(" \"%s\": %d次\n", word, freq)
|
||
}
|
||
|
||
// 示例4: 数据验证
|
||
fmt.Printf(" 示例4 - 用户数据验证:\n")
|
||
users := []map[string]string{
|
||
{"name": "Alice", "email": "alice@example.com", "age": "25"},
|
||
{"name": "", "email": "bob@test.com", "age": "30"},
|
||
{"name": "Charlie", "email": "invalid-email", "age": "abc"},
|
||
{"name": "David", "email": "david@domain.org", "age": "28"},
|
||
}
|
||
|
||
validUsers := 0
|
||
for i, user := range users {
|
||
fmt.Printf(" 用户 %d: ", i+1)
|
||
isValid := true
|
||
|
||
// 验证姓名
|
||
if user["name"] == "" {
|
||
fmt.Printf("姓名为空 ")
|
||
isValid = false
|
||
}
|
||
|
||
// 验证邮箱（简单验证）
|
||
email := user["email"]
|
||
if !contains(email, "@") || !contains(email, ".") {
|
||
fmt.Printf("邮箱无效 ")
|
||
isValid = false
|
||
}
|
||
|
||
// 验证年龄
|
||
age := user["age"]
|
||
if !isNumeric(age) {
|
||
fmt.Printf("年龄无效 ")
|
||
isValid = false
|
||
}
|
||
|
||
if isValid {
|
||
fmt.Printf("✓ 有效用户\n")
|
||
validUsers++
|
||
} else {
|
||
fmt.Printf("✗ 无效用户\n")
|
||
}
|
||
}
|
||
|
||
fmt.Printf(" 有效用户数: %d/%d\n", validUsers, len(users))
|
||
|
||
// 示例5: 矩阵操作
|
||
fmt.Printf(" 示例5 - 矩阵转置:\n")
|
||
matrix := [][]int{
|
||
{1, 2, 3},
|
||
{4, 5, 6},
|
||
}
|
||
|
||
fmt.Printf(" 原矩阵:\n")
|
||
for i, row := range matrix {
|
||
fmt.Printf(" 行 %d: %v\n", i, row)
|
||
}
|
||
|
||
// 创建转置矩阵
|
||
if len(matrix) > 0 {
|
||
transposed := make([][]int, len(matrix[0]))
|
||
for i := range transposed {
|
||
transposed[i] = make([]int, len(matrix))
|
||
}
|
||
|
||
for i, row := range matrix {
|
||
for j, value := range row {
|
||
transposed[j][i] = value
|
||
}
|
||
}
|
||
|
||
fmt.Printf(" 转置矩阵:\n")
|
||
for i, row := range transposed {
|
||
fmt.Printf(" 行 %d: %v\n", i, row)
|
||
}
|
||
}
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePerformanceConsiderations 演示 range 的性能考虑
|
||
func demonstratePerformanceConsiderations() {
|
||
fmt.Println("8. range 的性能考虑:")
|
||
|
||
// 大切片的遍历
|
||
fmt.Printf(" 大切片的遍历性能:\n")
|
||
largeSlice := make([]int, 1000)
|
||
for i := range largeSlice {
|
||
largeSlice[i] = i
|
||
}
|
||
|
||
// 使用 range（推荐）
|
||
sum1 := 0
|
||
for _, value := range largeSlice {
|
||
sum1 += value
|
||
if sum1 > 100 { // 提前退出演示
|
||
break
|
||
}
|
||
}
|
||
fmt.Printf(" 使用 range 遍历（推荐）: 部分和 = %d\n", sum1)
|
||
|
||
// 使用传统 for 循环
|
||
sum2 := 0
|
||
for i := 0; i < len(largeSlice); i++ {
|
||
sum2 += largeSlice[i]
|
||
if sum2 > 100 {
|
||
break
|
||
}
|
||
}
|
||
fmt.Printf(" 使用传统 for 循环: 部分和 = %d\n", sum2)
|
||
|
||
// 字符串遍历的性能
|
||
fmt.Printf(" 字符串遍历的性能考虑:\n")
|
||
longString := "这是一个包含中文字符的长字符串，用于演示遍历性能"
|
||
|
||
// 使用 range（处理 Unicode 正确）
|
||
charCount1 := 0
|
||
for range longString {
|
||
charCount1++
|
||
}
|
||
fmt.Printf(" 使用 range 统计字符数: %d\n", charCount1)
|
||
|
||
// 使用 len（字节数，不是字符数）
|
||
byteCount := len(longString)
|
||
fmt.Printf(" 使用 len 统计字节数: %d\n", byteCount)
|
||
|
||
// 使用 utf8.RuneCountInString（正确的字符数）
|
||
charCount2 := utf8.RuneCountInString(longString)
|
||
fmt.Printf(" 使用 utf8.RuneCountInString 统计字符数: %d\n", charCount2)
|
||
|
||
// 映射遍历的注意事项
|
||
fmt.Printf(" 映射遍历的注意事项:\n")
|
||
largeMap := make(map[int]string)
|
||
for i := 0; i < 10; i++ {
|
||
largeMap[i] = fmt.Sprintf("value_%d", i)
|
||
}
|
||
|
||
fmt.Printf(" 映射大小: %d\n", len(largeMap))
|
||
fmt.Printf(" 映射遍历顺序是随机的，每次运行可能不同\n")
|
||
|
||
// 显示前几个元素
|
||
count := 0
|
||
for key, value := range largeMap {
|
||
fmt.Printf(" %d: %s\n", key, value)
|
||
count++
|
||
if count >= 3 {
|
||
fmt.Printf(" ...\n")
|
||
break
|
||
}
|
||
}
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// 辅助函数
|
||
func contains(s, substr string) bool {
|
||
for i := 0; i <= len(s)-len(substr); i++ {
|
||
if s[i:i+len(substr)] == substr {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func isNumeric(s string) bool {
|
||
if len(s) == 0 {
|
||
return false
|
||
}
|
||
for _, char := range s {
|
||
if char < '0' || char > '9' {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
/*
|
||
运行这个程序：
|
||
go run 04-range.go
|
||
|
||
学习要点：
|
||
1. range 是 Go 中遍历集合类型的标准方式
|
||
2. range 可以用于数组、切片、字符串、映射和通道
|
||
3. range 返回索引/键和值，可以用 _ 忽略不需要的部分
|
||
4. range 会拷贝值，修改拷贝不会影响原始数据
|
||
5. 字符串的 range 遍历按 Unicode 字符，索引是字节位置
|
||
|
||
range 的语法：
|
||
- for index, value := range collection { ... }
|
||
- for index := range collection { ... } // 只要索引/键
|
||
- for _, value := range collection { ... } // 只要值
|
||
- for range collection { ... } // 只计数
|
||
|
||
不同类型的 range：
|
||
1. 数组/切片: 返回索引和值
|
||
2. 字符串: 返回字节位置和 Unicode 字符
|
||
3. 映射: 返回键和值（顺序随机）
|
||
4. 通道: 返回接收到的值（通道需要关闭）
|
||
|
||
性能考虑：
|
||
1. range 通常比传统 for 循环更高效和安全
|
||
2. 字符串的 range 正确处理 Unicode 字符
|
||
3. 大集合的遍历考虑提前退出
|
||
4. 映射遍历顺序是随机的
|
||
|
||
最佳实践：
|
||
1. 优先使用 range 遍历集合
|
||
2. 使用 _ 忽略不需要的返回值
|
||
3. 注意 range 的值拷贝特性
|
||
4. 字符串处理时考虑 Unicode 字符
|
||
5. 通道遍历前确保通道会被关闭
|
||
|
||
常见应用场景：
|
||
1. 数据处理和统计
|
||
2. 配置文件解析
|
||
3. 文本分析
|
||
4. 数据验证
|
||
5. 矩阵操作
|
||
6. 集合操作
|
||
*/ |