golang基础使用示例

Leefs 2024-03-31 PM 302℃ 0条

[TOC]

### 一、map、slice简单使用示例

#### **（1）使用 slice 存储 map 列表**

```golang
import "fmt"

// 使用 slice 存储 map 列表
func main() {
	// 创建一个空的 map 切片
	// data是一个切片，其元素类型是map[string]int
	// data可以包含多个map，每个map的键是字符串类型，值是整数类型
	var data []map[string]int

// 向切片中添加 map 元素
	data = append(data, map[string]int{"a": 1, "b": 2})
	data = append(data, map[string]int{"x": 10, "y": 20})

// 遍历切片,并输出每个 map 的值
	// 外层循环遍历data切片中的每个map元素
	for _, m := range data {
		for key, value := range m {
			fmt.Printf("%s: %d\n", key, value)
		}
	}
}
```

#### **（2）使用 map 存储 slice 列表**

```go
import "fmt"

func main() {
	// 创建一个map,键为字符串,值为整数切片
	// data 是一个map，其键（key）是字符串类型string，值（value）是整数切片[]int
	data := make(map[string][]int)

// 向 map 中添加数据
	data["even"] = []int{2, 4, 6, 8, 20}
	data["odd"] = []int{1, 3, 5, 7, 9}

// 遍历map,并输出值
	// 在每次迭代中，key变量将包含当前的键，value变量将包含对应的值。
    // range关键字用于获取map中的键值对。
	for key, value := range data {
		fmt.Printf("%s: %v\n", key, value)
		// index：表示每一个元素的索引
		// num：表示每一个元素的值
		for index, num := range value {
			fmt.Printf("Index: %d Num: %d\n", index, num)
		}
	}
}
```

#### **（3）使用 map 存储包含 slice 结构体**

```go
import "fmt"

type Person struct {
	Name      string
	Interests []string
}

func main() {
	// 创建一个 map,键为姓名,值为 Person 结构体
	people := make(map[string]Person)

// 添加数据到 map 中
	people["Alice"] = Person{Name: "Alice", Interests: []string{"Golang", "Programming"}}
	people["Bob"] = Person{Name: "Bob", Interests: []string{"Python", "Data Science"}}

// 遍历 map,并输出每个人的兴趣爱好
	for _, p := range people {
		fmt.Printf("%s's interests: %v\n", p.Name, p.Interests)
	}
}
```

**输出结果**

```
Alice's interests: [Golang Programming] 
Bob's interests: [Python Data Science] 
```

#### **（4）使用 map 存储包含 slice 的结构体列表**

```golang
type Item struct {
	ID   int
	Name string
}

func main() {
	// 创建一个 map，键为字符串，值为 Item 结构体切片
	items := make(map[string][]Item)

// 向 map 中添加数据
	items["fruits"] = []Item{{ID: 1, Name: "Apple"}, {ID: 2, Name: "Banana"}}
	items["vegetables"] = []Item{{ID: 3, Name: "Carrot"}, {ID: 4, Name: "Broccoli"}}

// 遍历 map，并输出值
	for category, itemList := range items {
		fmt.Printf("%s:\n", category)
		for _, item := range itemList {
			fmt.Printf("ID: %d, Name: %s\n", item.ID, item.Name)
		}
	}
}
```

**输出结果**

```
fruits:
ID: 1, Name: Apple    
ID: 2, Name: Banana   
vegetables:           
ID: 3, Name: Carrot   
ID: 4, Name: Broccoli 
```

#### **（5）使用 slice 存储包含 map 的结构体列表**

```golang
import "fmt"

type Person2 struct {
	Name string
	Age  int
}

func main() {
	// 创建一个空的 Person 结构体切片
	var people []Person2

// 向切片中添加 map 元素
	people = append(people, Person2{Name: "Alice", Age: 25})
	people = append(people, Person2{Name: "Bob", Age: 30})

// 遍历切片，并输出每个人的信息
	for _, p := range people {
		fmt.Printf("Name: %s, Age: %d\n", p.Name, p.Age)
	}
}
```

**运行结果**

```
Name: Alice, Age: 25 
Name: Bob, Age: 30  
```

### 二、使用案例

#### 2.1 统计每个单词在文本中出现的次数

```go
import (
	"fmt"
	"regexp"
	"strings"
)

func main() {
	text := "This is a test. This test is only a test."
	wordCounts := make(map[string][]int)

// 去掉字符串中的特殊符号
	// 方法一 Replace
	// -1 表示替换所有匹配的子串。
	//text = strings.Replace(text, ".", "", -1)

// 方法二 NewReplacer
	//创建一个Replacer，用于替换多个不同的符号
	//replacer := strings.NewReplacer(".", "", "-", "", "!", "", "?", "")
	// 使用Replacer来替换字符串中的符号
	//text = replacer.Replace(text)

//方法三 正则表达式
	// 正则表达式匹配所有非字母数字的字符,保留空格
	re := regexp.MustCompile(`[^a-zA-Z0-9\s]+`)
	// 使用空字符串替换所有匹配到的特殊符号
	text = re.ReplaceAllString(text, "")

// 将文本分割成单词
	words := strings.Fields(text)

// 遍历每个单词并统计出现次数
	for _, word := range words {
		word = strings.ToLower(word) // 转换为小写以忽略大小写
		if _, exits := wordCounts[word]; !exits {
			wordCounts[word] = []int{1} // 新单词,初始化计数为1的切片
		} else {
			// 追加新的计数到切片
			wordCounts[word] = append(wordCounts[word], wordCounts[word][len(wordCounts[word])-1]+1)
		}
	}

// 打印结果
	for word, counts := range wordCounts {
		fmt.Printf("Word: %s, Counts: %v\n", word, counts)
	}
}
```

+ **运行结果**

```
Word: test, Counts: [1 2 3]
Word: only, Counts: [1]   
Word: this, Counts: [1 2] 
Word: is, Counts: [1 2]   
Word: a, Counts: [1 2] 
```

#### 2.2 TopN

+ 求数组中出现前N个数的数值

```go
import (
	"fmt"
	"sort"
)

// 定义一个结构体来存储元素和它的出现次数
type ElementCount struct {
	Element int
	Count   int
}

// 按照出现次数降序排序
type ByCount []ElementCount

func (a ByCount) Len() int           { return len(a) }
func (a ByCount) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByCount) Less(i, j int) bool { return a[i].Count > a[j].Count }

// TopN 函数统计整数切片中出现次数最多的前N个元素
func TopN(numbers []int, n int) []ElementCount {
	// 使用map来统计每个元素的出现次数
	counts := make(map[int]int)
	for _, num := range numbers {
		counts[num]++
	}

// 将统计结果放入切片中
	var elements []ElementCount
	for element, count := range counts {
		elements = append(elements, ElementCount{Element: element, Count: count})
	}

// 根据出现次数进行排序
	sort.Sort(ByCount(elements))

// 返回前N个元素
	if len(elements) > n {
		return elements[:n]
	}
	return elements
}

func main() {
	// 示例数据
	numbers := []int{1, 2, 3, 2, 3, 3, 4, 4, 4, 4, 5}
	n := 3 // 我们要找的前3个出现次数最多的元素

// 调用TopN函数并打印结果
	topElements := TopN(numbers, n)
	for _, elem := range topElements {
		fmt.Printf("Element: %d, Count: %d\n", elem.Element, elem.Count)
	}
}
```

+ **运行结果**

```
Element: 4, Count: 4 
Element: 3, Count: 3 
Element: 2, Count: 2 
```

#### 2.3 聚合统计

+ 对文件`numbers.txt`中的数字进行聚合统计,包括：总数、求和、最大值、最小值、平均值

```
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
```

+ **代码**

```go
import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

// 统计信息结构体
type Stats struct {
	Count   int     // 数据总数
	Sum     int     // 数据总和
	Min     int     // 最小值
	Max     int     // 最大值
	Average float64 // 平均值
}

// 从文件中读取整数并返回切片
func readIntsFromFile(filename string) ([]int, error) {
	var numbers []int
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		// 去除空白字符并分割字符串
		fields := strings.Fields(line)
		for _, field := range fields {
			// 将字符串转换为整数
			num, err := strconv.Atoi(field)
			if err != nil {
				fmt.Printf("Skipping non-integer: %s\n", field)
				continue
			}
			numbers = append(numbers, num)
		}
	}

if err := scanner.Err(); err != nil {
		return nil, err
	}

return numbers, nil
}

// 计算并返回统计信息
func calculateStats(numbers []int) Stats {
	var stats Stats
	stats.Count = len(numbers)
	if stats.Count == 0 {
		return stats
	}

stats.Sum = 0
	stats.Min = numbers[0]
	stats.Max = numbers[0]

for _, num := range numbers {
		stats.Sum += num
		if num < stats.Min {
			stats.Min = num
		}
		if num > stats.Max {
			stats.Max = num
		}
	}

stats.Average = float64(stats.Sum) / float64(stats.Count)

return stats
}

func main() {
	// 文件名，这里假设有一个名为numbers.txt的文件包含整数
	filename := "data/numbers.txt"

// 从文件中读取整数
	numbers, err := readIntsFromFile(filename)
	if err != nil {
		fmt.Printf("Error reading file: %v\n", err)
		return
	}

// 计算统计信息
	stats := calculateStats(numbers)

// 输出统计信息
	fmt.Printf("Count: %d\n", stats.Count)
	fmt.Printf("Sum: %d\n", stats.Sum)
	fmt.Printf("Min: %d\n", stats.Min)
	fmt.Printf("Max: %d\n", stats.Max)
	fmt.Printf("Average: %.2f\n", stats.Average)
}
```

#### 2.4 分页

+ 对数组进行分页输出

```go
import (
	"fmt"
	"math"
)

func SlicePage(page, pageSize, nums int) (sliceStart, sliceEnd int) {
	if page <= 0 {
		page = 1 // 设置默认页码
	}
	if pageSize < 0 {
		pageSize = 10 // 设置一页默认显示的记录数
	}

// 总页数
	// math.Ceil 向上取整
	pageCount := int(math.Ceil(float64(nums) / float64(pageSize)))
	// 处理 当前页码 > 总页数
	if page > pageCount {
		return 0, 0
	}
	// 处理 一页默认显示的记录数 > 总记录数
	if pageSize > nums {
		return 0, nums
	}

sliceStart = (page - 1) * pageSize
	sliceEnd = sliceStart + pageSize

if sliceEnd > nums {
		sliceEnd = nums
	}
	return sliceStart, sliceEnd
}
func main() {
	data := []string{"a", "b", "c", "d", "e"} // 数组

page := 2
	size := 2

start, end := SlicePage(page, size, len(data))
	pageData := data[start:end]
	fmt.Println(pageData)
}
```

+ **运行结果**

```
[c d]
```

标签: Golang

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/2877.html

上一篇 golang之context介绍

下一篇 golang之gorm操作示例并兼容达梦数据库

golang基础使用示例

评论啦~

栏目分类

标签云

友情链接申请

golang基础使用示例

 评论啦~

 栏目分类

标签云

友情链接申请

评论啦~

栏目分类

标签云

友情链接申请