Go语言->练习6例

发布于:2025-05-01 ⋅ 阅读:(21) ⋅ 点赞:(0)

1.go语言的接口实现

接口(interface)是一种类型,它定义了一组方法的集合。任何类型只要实现了接口中定义的所有方法,就被认为实现了该接口。

在Go语言中,使用接口的最佳实践可以提高代码的可读性、可维护性和灵活性。

  • 小接口与大接口: 尽量设计小接口,一个接口应该只包含少量的方法,而不是设计一个大而全的接口。这样可以避免实现接口时不必要的负担,并使接口更具通用性。
  • 基于使用场景设计接口: 设计接口时应该考虑使用场景,而不是从具体的实现出发。思考在你的应用程序中如何使用接口,以及接口应该提供哪些方法来满足这些使用场景。
  • 使用合适的命名: 为接口和方法使用清晰的命名,使其能够表达出其用途和功能。命名应该具有可读性和表达性,让其他开发者能够轻松理解接口的用途。
  • 避免不必要的接口: 不要为每个类型都创建一个接口,只有在多个类型之间确实存在共享的行为和功能时才使用接口。不要过度使用接口,以免导致不必要的复杂性。
  • 使用接口作为函数参数和返回值: 使用接口作为函数参数和返回值,可以使函数更加通用,允许传入不同类型的参数,并返回不同类型的结果。这可以提高代码的复用性和扩展性。
  • 注释和文档: 为接口提供清晰的文档和注释,说明接口的用途、方法的功能和预期行为。这可以帮助其他开发者更好地理解接口的使用方式。
  • 用例驱动设计: 在设计接口时,可以从使用的角度出发,先考虑接口在实际场景中如何被调用,然后再设计接口的方法和签名。
  • 将接口的实现与定义分离: 将接口的实现与接口的定义分开,这样可以使实现更灵活,可以在不修改接口定义的情况下实现新的类型。
  • 默认实现: 在接口定义中,可以为某些方法提供默认实现,从而减少实现接口时的工作量。这对于可选方法或者某些方法的默认行为很有用。
  • 使用空接口谨慎: 使用空接口(interface{})应谨慎,因为它会降低类型安全性。只有在确实需要处理不同类型的值时才使用空接口,同时要注意类型断言和错误处理。

设计和使用接口时要根据实际需求和项目的特点来选择合适的方案。

package main

import "fmt"

type Shape interface {
	Area() float64
	Perimeter() float64
}

type Rectangle struct {
	Width  float64
	Height float64
}

func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Height + r.Width)
}

func main() {
	var s Shape
	rect := Rectangle{Height: 3, Width: 4}
	s = rect

	fmt.Println("面积:", s.Area())
	fmt.Println("周长:", s.Perimeter())
}


// 理解与记忆方法
// 1接口是方法的集合:接口定义了一组方法,任何类型实现了这些方法就实现了接口。
// 2隐式实现:Go 不需要显式声明实现某个接口,只要类型的方法集包含接口的所有方法即可。
// 3空接口:interface{} 是最通用的接口,可存储任何类型值,用于灵活性需求。
// 4接口值的内部结构:接口值包含动态类型信息和实际数据值,支持类型断言和类型切换。
// 5鸭子类型:如果一个东西走起来像鸭子,叫起来也像鸭子,那么它就是鸭子。即,只要类型实现了接口的方法,就被认为实现了接口。

输出结果:

Running] go run "d:\Microsoft VS Code\GOproject\src\go_code\chapter\interface\testshape\shape.go"
面积: 12
周长: 14

[Done] exited with code=0 in 0.911 seconds

2.go语言中如何访问私有成员

导出公有方法(get和set)

package main

import "fmt"

//定义一个结构体
type Person struct {
	name string
	age  int
}

//导出Get方法,获取Name
func (p *Person) GetName() string {
	return p.name
}

//导出Set方法,设置Name
func (p *Person) SetName(newName string) {
	p.name = newName
}

//导出Get方法,获取Age
func (p *Person) GetAge() int {
	return p.age
}

//导出Set方法,设置Age
func (p *Person) SetAge(newAge int) {
	if newage > 0 {
		p.Age = newage
	} else {
		fmt.Println("年龄不能为负")
	}
}

func main() {
	//创建zhangsan实例
	person := Person{
		name: "zhangsan",
		age:  18,
	}
	//调用Get方法
	fmt.Println("姓名:", person.GetName())
	fmt.Println("年龄:", person.GetAge())
	//输出结果:
	// 姓名: zhangsan
	// 年龄: 18

	//调用Set方法
	person.SetName("Lis")
	person.SetAge(20)
	fmt.Println("新名字:", person.GetName())
	fmt.Println("新年龄:", person.GetAge())

	//测试非法参数
	person.SetAge(-18)
}

输出结果:

[Running] go run "d:\Microsoft VS Code\GOproject\src\go_code\chapter4\main.go"
姓名: zhangsan
年龄: 18
新名字: Lis
新年龄: 20
年龄不能为负

[Done] exited with code=0 in 1.271 seconds

3.《剪刀石头布》游戏;

设计思路:石头剪刀布分别用0、1、2,来表示

系统随机输出一个数字,用户通过命令行输入数字,进行对比,决定出是用户获胜还是系统获胜(采用数学思想),设计避免用户输入其他数字,输入其他数字输出“请输入正确的数字”,然后重新让用户输入。

package main

import (
	"bufio"  // 用于读取用户输入
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	// 初始化随机数种子
	localRand := rand.New(rand.NewSource(time.Now().UnixNano()))

	// 初始化随机数种子
	computer := localRand.Intn(3)

	// 获取用户的有效输入
	user := getUserInput()

	// 显示双方选择
	names := []string{"石头", "剪刀", "布"}

	// 显示对战结果
	fmt.Printf("\n你出了%s,系统出了%s。\n", names[user], names[computer])

	//判断并显示结果
	switch determineWinner(user, computer) {
	case 0:
		fmt.Println("平局")
	case 1:
		fmt.Println("你赢了!好腻害呀!")
	case -1:
		fmt.Println("系统赢了!")
	}
}

// 判断胜负函数
func determineWinner(user, computer int) int {
	//使用数学公式判断胜负关系
	switch (user - computer + 3) % 3 {
	case 0:
		return 0 //平局
	case 1:
		return -1 //系统赢
	default:
		return 1 //用户赢
	}
}

func getUserInput() int {
	reader := bufio.NewReader(os.Stdin)

	// 使用无限循环直到获得有效输入
	for {
		fmt.Print("请出拳(0: 石头,1: 剪刀,2: 布):")

		// 读取输入直到遇到换行符(Windows系统注意换行符是\r\n)
		input, _ := reader.ReadString('\n')
		// 去除首尾空白字符(包括可能的空格和换行符)
		input = strings.TrimSpace(input)

		// 将字符串转换为整数
		num, err := strconv.Atoi(input)
		if err != nil {
			fmt.Println("请输入整数") // 处理非数字输入
			continue
		}

		// 验证输入范围(建议先显示错误再判断范围)
		if num < 0 || num > 2 {
			fmt.Println("请输入0-2之间的数字!")
			continue
		}
		return num
	}
}

测试:

PS D:\Microsoft VS Code\GOproject\src\go_code\project1> go run .\3-1.go
请出拳(0: 石头,1: 剪刀,2:):1

你出来剪刀,系统出了剪刀。
平局
PS D:\Microsoft VS Code\GOproject\src\go_code\project1> go run .\3-1.go
请出拳(0: 石头,1: 剪刀,2:):3
请输入0-2之间的数字!
请出拳(0: 石头,1: 剪刀,2:):4
请输入0-2之间的数字!
请出拳(0: 石头,1: 剪刀,2:):2

你出来布,系统出了布。
平局
PS D:\Microsoft VS Code\GOproject\src\go_code\project1> go run .\3-1.go
请出拳(0: 石头,1: 剪刀,2:):1

你出来剪刀,系统出了布。
你赢了!好腻害呀!
PS D:\Microsoft VS Code\GOproject\src\go_code\project1> go run .\3-1.go
请出拳(0: 石头,1: 剪刀,2:):0

你出了石头,系统出了剪刀。
你赢了!好腻害呀!
PS D:\Microsoft VS Code\GOproject\src\go_code\project1> 

4. 猜数字游戏

一个小游戏:在0-999之间随机生成一个数,用户在终端进行猜测,假设说生成的数字是100,用户第一次猜200,那么就提示用户“答案在在0-200区间”,以此类推,直到用户答出争取的数字,并输出”您成功答出正确答案:答案;共猜了n次“

package main

import (
	"bufio" // 用于读取用户输入
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
)

func main() {

	// 初始化随机数种子
	target := rand.Intn(1000)
	low, high := 0, 999
	attempts := 0

	reader := bufio.NewReader(os.Stdin)
	fmt.Println("数字猜谜游戏开始!请输入0-999的随机整数:")

	for {
		fmt.Printf("(%d尝试,当前范围[%d-%d])", attempts, low, high)
		input, _ := reader.ReadString('\n')
		input = strings.TrimSpace(input)

		reader.Reset(os.Stdin)

		guess, err := strconv.Atoi(input)

		if err != nil || guess < low || guess > high {
			fmt.Printf("请输入%d-%d范围内的有效整数\n", low, high)
			continue
		}

		attempts++
		if guess == target {
			fmt.Printf("您成功答出正确答案:%d(共尝试%d次)\n", target, attempts)
			break
		} else if guess > target {
			high = guess - 1
			fmt.Printf("答案在更小的范围内\n")
		} else {
			low = guess + 1
			fmt.Printf("答案在更大的范围内\n")
		}

	}
}

输出测试:

PS D:\Microsoft VS Code\GOproject\src\go_code\project2> go run .\1.go
数字猜谜游戏开始!请输入0-999的随机整数:
(0尝试,当前范围[0-999])500
答案在更小的范围内
(1尝试,当前范围[0-499])300
答案在更大的范围内
(2尝试,当前范围[301-499])400
答案在更小的范围内
(3尝试,当前范围[301-399])150
请输入301-399范围内的有效整数
(3尝试,当前范围[301-399])350
答案在更大的范围内
(4尝试,当前范围[351-399])375
答案在更大的范围内
(5尝试,当前范围[376-399])190
请输入376-399范围内的有效整数
(5尝试,当前范围[376-399])390
答案在更小的范围内
(6尝试,当前范围[376-389])380
答案在更大的范围内
(7尝试,当前范围[381-389])385
答案在更大的范围内
(8尝试,当前范围[386-389])388
答案在更大的范围内
(9尝试,当前范围[389-389])389
您成功答出正确答案:389(共尝试10次)
PS D:\Microsoft VS Code\GOproject\src\go_code\project2> 

简易学生查询系统

使用Go语言写一个教学管理系统,存储学生名字、学生年龄、学生班级、学习成绩(ABCDE由高到低),然后给用户一个终端输入的模块,输入1查询学生的基本信息(名字、班级年龄),输入2查询学生成绩,输入3添加学生信息,输入4删除学生信息,输入5查询所有学生信息,输入6退出系统;要注意其中输入非指定信息出现的问题如何解决,开始吧。

代码实现:

package main

// 导入需要的包
import (
	"bufio"   // 用于读取输入
	"fmt"     // 用于输入输出格式化
	"os"      // 用于操作系统交互
	"strconv" // 用于字符串和数字转换
	"strings" // 用于字符串处理
)

// 定义学生结构体,用于存储单个学生的完整信息
type Student struct {
	Name  string // 学生姓名
	Age   int    // 学生年龄
	Class string // 学生所在班级
	Grade string // 学生成绩等级(A-E)
}

// 全局变量:使用切片存储所有学生信息(切片是动态数组,可以自动扩展)
var students []Student

// 查询学生基本信息函数
func queryStudentInfo(scanner *bufio.Scanner) {
	fmt.Print("请输入要查询的学生姓名:")
	scanner.Scan()                            // 读取用户输入
	name := strings.TrimSpace(scanner.Text()) // 去除前后空格

	found := false // 标记是否找到学生
	// 遍历所有学生
	for _, s := range students {
		// 使用不区分大小写的比较(比如输入"zhangsan"可以匹配"ZhangSan")
		if strings.EqualFold(s.Name, name) {
			// 使用格式化输出显示学生信息
			fmt.Printf("\n学生信息:\n姓名:%s\n年龄:%d\n班级:%s\n",
				s.Name, s.Age, s.Class)
			found = true
		}
	}
	if !found {
		fmt.Println("未找到该学生信息")
	}
}

// 查询学生成绩函数
func queryStudentGrade(scanner *bufio.Scanner) {
	fmt.Print("请输入要查询成绩的学生姓名:")
	scanner.Scan()
	name := strings.TrimSpace(scanner.Text())

	found := false
	// 遍历学生切片查找匹配项
	for _, s := range students {
		if strings.EqualFold(s.Name, name) {
			fmt.Printf("\n学生成绩:\n姓名:%s\n成绩:%s\n",
				s.Name, s.Grade)
			found = true
		}
	}
	if !found {
		fmt.Println("未找到该学生信息")
	}
}

// 添加学生信息函数
func addStudent(scanner *bufio.Scanner) {
	var student Student // 创建新的学生对象

	// 收集学生信息并进行验证
	fmt.Print("请输入学生姓名:")
	scanner.Scan()
	student.Name = strings.TrimSpace(scanner.Text())

	fmt.Print("请输入学生年龄:")
	scanner.Scan()
	// 将字符串转换为整数,并进行有效性检查
	age, err := strconv.Atoi(strings.TrimSpace(scanner.Text()))
	if err != nil || age < 0 { // 检查是否为合法年龄
		fmt.Println("无效的年龄输入")
		return // 直接返回,不继续执行
	}
	student.Age = age

	fmt.Print("请输入学生班级:")
	scanner.Scan()
	student.Class = strings.TrimSpace(scanner.Text())

	fmt.Print("请输入学生成绩(ABCDE):")
	scanner.Scan()
	// 处理成绩输入:转换为大写并去除空格
	grade := strings.ToUpper(strings.TrimSpace(scanner.Text()))
	if !isValidGrade(grade) { // 检查成绩是否合法
		fmt.Println("无效的成绩输入")
		return
	}
	student.Grade = grade

	// 将新学生添加到全局切片中
	students = append(students, student)
	fmt.Println("学生信息添加成功!")
}

// 删除学生信息函数
func deleteStudent(scanner *bufio.Scanner) {
	fmt.Print("请输入要删除的学生姓名:")
	scanner.Scan()
	name := strings.TrimSpace(scanner.Text())

	// 创建新切片保存保留的学生
	newStudents := make([]Student, 0)
	found := false

	// 遍历所有学生,过滤掉要删除的
	for _, s := range students {
		if strings.EqualFold(s.Name, name) {
			found = true // 标记找到要删除的学生
		} else {
			// 将不需要删除的学生加入新切片
			newStudents = append(newStudents, s)
		}
	}

	if found {
		students = newStudents // 用新切片替换原切片
		fmt.Println("学生信息删除成功!")
	} else {
		fmt.Println("未找到该学生信息")
	}
}

// 显示所有学生信息函数
func displayAllStudent() {
	// 处理空数据情况
	if len(students) == 0 {
		fmt.Println("当前没有学生信息")
		return
	}

	// 使用表格形式展示数据
	fmt.Println("\n所有学生信息:")
	fmt.Println("========================================")
	// 遍历切片,i是索引(从0开始),s是学生对象
	for i, s := range students {
		// 格式化输出:%-8s表示左对齐,占8个字符宽度
		fmt.Printf("%d. 姓名:%-8s 年龄:%-3d 班级:%-6s 成绩:%s\n",
			i+1, s.Name, s.Age, s.Class, s.Grade)
	}
	fmt.Println("========================================")
	fmt.Printf("共 %d 条学生记录\n", len(students))
}

// 验证成绩是否合法的函数
func isValidGrade(grade string) bool {
	// 使用map实现快速查找,合法成绩字典
	validGrades := map[string]bool{
		"A": true,
		"B": true,
		"C": true,
		"D": true,
		"E": true,
	}
	return validGrades[grade] // 返回查找结果
}

// 主函数:程序入口
func main() {
	// 创建输入扫描器,用于读取标准输入(键盘输入)
	scanner := bufio.NewScanner(os.Stdin)

	// 无限循环显示菜单,直到用户选择退出
	for {
		// 打印菜单选项
		fmt.Println("\n教学管理系统")
		fmt.Println("1. 查询学生基本信息")
		fmt.Println("2. 查询学生成绩")
		fmt.Println("3. 添加学生信息")
		fmt.Println("4. 删除学生信息")
		fmt.Println("5. 显示所有学生信息")
		fmt.Println("6. 退出系统")
		fmt.Print("请选择操作编号:")

		scanner.Scan()                             // 等待用户输入
		input := strings.TrimSpace(scanner.Text()) // 处理输入

		// 使用switch-case处理用户选择
		switch input {
		case "1":
			queryStudentInfo(scanner)
		case "2":
			queryStudentGrade(scanner)
		case "3":
			addStudent(scanner)
		case "4":
			deleteStudent(scanner)
		case "5":
			displayAllStudent()
		case "6":
			fmt.Println("感谢使用,再见!")
			return // 结束程序
		default:
			fmt.Println("无效的输入,请重新输入")
		}
	}
}

进行测试:

PS D:\Microsoft VS Code\GOproject\src\go_code\student> .\studentmain.exe

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:1
请输入要查询的学生姓名:hzy
未找到该学生信息

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:3
请输入学生姓名:hzy
请输入学生年龄:19   
请输入学生班级:Cloud1
请输入学生成绩(ABCDE):A
学生信息添加成功!

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:
无效的输入,请重新输入


教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:1
请输入要查询的学生姓名:hzy 

学生信息:
姓名:hzy
年龄:19
班级:Cloud1

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:2
请输入要查询成绩的学生姓名:hzy

学生成绩:
姓名:hzy
成绩:A

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:5

所有学生信息:
========================================
1. 姓名:hzy      年龄:19  班级:Cloud1 成绩:A
========================================1 条学生记录

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:4
请输入要删除的学生姓名:hzy
学生信息删除成功!

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:5
当前没有学生信息

教学管理系统
1. 查询学生基本信息
2. 查询学生成绩
3. 添加学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 退出系统
请选择操作编号:6
感谢使用,再见!
PS D:\Microsoft VS Code\GOproject\src\go_code\student> 

文件查找:

使用Go语言做一个简易的文件查询系统,比如在某个文件夹下,存放一些.txt文件,现在使用Go语言去搜索文件名,搜索文件名之后直接查看文件,类似于Linux里面的ls命令找到文件后使用cat命令一个道理。开始吧。

// 文件查询系统 - 支持按名称搜索文本文件并查看内容
package main

// 导入所需的标准库包
import (
	"bufio"         // 带缓冲的输入输出处理
	"fmt"           // 格式化输入输出
	"os"            // 操作系统功能(文件、目录操作)
	"path/filepath" // 跨平台文件路径处理
	"strconv"       // 字符串与数值类型转换
	"strings"       // 字符串处理工具
)

// 配置常量(建议根据实际情况修改路径)
const (
	searchDir = "D:/Microsoft VS Code/GOproject/src/go_code/txtlist" // 要搜索的根目录
	fileExt   = ".txt"                                               // 要搜索的文件扩展名
)

// searchFile 文件搜索主功能
// scanner: 从标准输入读取数据的扫描器
func searchFile(scanner *bufio.Scanner) {
	// 获取用户搜索关键词
	fmt.Print("\n请输入关键词:")
	scanner.Scan()
	keyword := strings.TrimSpace(scanner.Text()) // 去除前后空格

	// 执行文件搜索
	files, err := findFiles(keyword)
	if err != nil {
		fmt.Printf("搜索失败: %v\n", err)
		return
	}

	// 处理空结果情况
	if len(files) == 0 {
		fmt.Println("没有找到匹配的文件")
		return
	}

	// 显示搜索结果列表
	fmt.Println("\n找到以下文件:")
	for i, file := range files {
		fmt.Printf("%d. %s\n", i+1, file) // 显示带编号的文件路径
	}

	// 处理用户选择
	fmt.Print("\n请输入编号查看文件内容(输入0返回上级):")
	scanner.Scan()
	choice := strings.TrimSpace(scanner.Text())

	// 转换用户输入为数字
	index, err := strconv.Atoi(choice)
	// 验证输入有效性(重要!防止无效输入导致程序崩溃)
	if err != nil || index < 0 || index > len(files) {
		fmt.Println("无效的选择")
		return
	}

	// 显示选定文件内容
	if index > 0 {
		showFileContent(files[index-1]) // 注意索引从1开始显示,实际存储从0开始
	}
}

// showFileContent 显示文件内容
// filePath: 要显示文件的完整路径
func showFileContent(filePath string) {
	// 读取文件全部内容(适用于小文件)
	content, err := os.ReadFile(filePath)
	if err != nil {
		fmt.Printf("读取文件失败:%v\n", err)
		return
	}

	// 格式化输出文件内容
	fmt.Printf("\n文件内容 [%s]:\n%s\n",
		filepath.Base(filePath), // 仅显示文件名(不含路径)
		string(content))         // 字节切片转字符串

	// 暂停等待用户确认
	fmt.Println("------------------------------")
	fmt.Print("按回车键继续...")
	bufio.NewReader(os.Stdin).ReadBytes('\n') // 读取直到回车键
}

// findFiles 递归查找匹配文件
// keyword: 搜索关键词(不区分大小写)
// 返回值: 匹配文件路径切片,错误信息
func findFiles(keyword string) ([]string, error) {
	var matches []string // 存储匹配文件路径

	// 检查目录是否存在(重要错误处理)
	if _, err := os.Stat(searchDir); os.IsNotExist(err) {
		return nil, fmt.Errorf("目录不存在: %s", searchDir)
	}

	// 递归遍历目录(核心文件搜索逻辑)
	err := filepath.Walk(searchDir, func(path string, info os.FileInfo, err error) error {
		// 错误优先处理原则
		if err != nil {
			return fmt.Errorf("访问路径失败: %w", err) // 包装错误信息
		}

		// 筛选条件(同时满足三个条件):
		// 1. 是文件(非目录)
		// 2. 扩展名匹配
		// 3. 文件名包含关键词(不区分大小写)
		if !info.IsDir() &&
			strings.HasSuffix(info.Name(), fileExt) &&
			strings.Contains(strings.ToLower(info.Name()), strings.ToLower(keyword)) {
			matches = append(matches, path) // 记录匹配路径
		}

		return nil // 必须返回nil表示继续遍历
	})

	return matches, err
}

// main 程序入口函数
func main() {
	// 创建标准输入扫描器
	scanner := bufio.NewScanner(os.Stdin)

	// 主循环(保持程序持续运行)
	for {
		// 显示操作菜单
		fmt.Print("\n文件查询系统\n")
		fmt.Println("1. 搜索文件")
		fmt.Println("2. 退出系统")
		fmt.Print("请选择操作:")

		// 获取用户输入
		scanner.Scan()
		input := strings.TrimSpace(scanner.Text())

		// 处理菜单选择
		switch input {
		case "1":
			searchFile(scanner)
		case "2":
			fmt.Println("感谢使用,再见!")
			return // 结束程序
		default:
			fmt.Println("无效的输入,请重新选择")
		}
	}
}

测试结果:(提前准备一些测试文件)

PS D:\Microsoft VS Code\GOproject\src\go_code\foundtxt> go run .\foundtxt.go

文件查询系统
1. 搜索文件
2. 退出系统
请选择操作:1

请输入关键词:yum

找到以下文件:
1. D:\Microsoft VS Code\GOproject\src\go_code\txtlist\yum.txt

请输入编号查看文件内容(输入0返回上级):
无效的选择

文件查询系统
1. 搜索文件
2. 退出系统
请选择操作:1  

请输入关键词:yum

找到以下文件:
1. D:\Microsoft VS Code\GOproject\src\go_code\txtlist\yum.txt

请输入编号查看文件内容(输入0返回上级):1

文件内容 [yum.txt]:
yum 可以下载文件。
------------------------------
按回车键继续...

文件查询系统
1. 搜索文件
2. 退出系统
请选择操作:无效的输入,请重新选择

文件查询系统
1. 搜索文件
2. 退出系统
exit status 0xc000013a
PS D:\Microsoft VS Code\GOproject\src\go_code\foundtxt> 

网站公告

今日签到

点亮在社区的每一天
去签到