答案：使用Go语言实现一个命令行任务提醒工具，通过Task结构体定义任务属性，JSON文件持久化存储，time.AfterFunc实现定时提醒，程序启动时加载任务并调度，支持添加、查看、完成和删除任务。
写一个小型任务提醒工具，用Golang实现，其实并不复杂，核心在于任务的定义、存储以及一个简单的调度机制。你可以把它想象成一个命令行下的迷你版日程助理，帮你记住那些不容错过的小事。
解决方案
要实现这样一个工具，我们可以从几个关键点入手：首先是任务的数据结构，它决定了我们能记录哪些信息；接着是任务的存储，确保数据不会随着程序关闭而丢失；最后，也是最关键的，是任务的调度和提醒，让程序能在正确的时间“叫醒”你。
我的思路是，用一个Go结构体来定义任务，包含ID、标题、描述、提醒时间以及完成状态。为了简化，存储部分可以考虑使用JSON文件，读写方便，对小型数据量非常友好。至于提醒，Go的
time.AfterFunc
配合goroutine就能优雅地实现单次提醒，而如果需要更复杂的周期性提醒，可以考虑引入像
robfig/cron
这样的库，不过对于“小型”工具，我们先聚焦在基础功能上。
程序启动时，会从文件加载所有未完成的任务，然后为每个任务设置一个
time.AfterFunc
，当时间到达时，就打印提醒信息。用户可以通过命令行指令添加、查看、完成任务。这样，一个基本的任务提醒工具就有了雏形。
立即学习“go语言免费学习笔记（深入）”；
如何设计一个简洁高效的任务数据结构？
设计任务的数据结构，就像在给你的“备忘录”定规矩，得想清楚它需要记录什么。对我来说，一个任务至少得有几个基本属性：一个独一无二的标识符，方便操作；一个标题，一眼就知道是啥事；一个详细描述，记录更多上下文；当然，最重要的是提醒时间，这是提醒工具的灵魂；最后，一个状态，比如“已完成”或“待办”，管理起来才清晰。
我们可以在Golang中这样定义它：
package main import ( "fmt" "time" ) // Task 定义了任务的数据结构 type Task struct { ID string `json:"id"` // 任务唯一标识符 Title string `json:"title"` // 任务标题 Description string `json:"description"` // 任务详细描述 DueTime time.Time `json:"due_time"` // 提醒时间 IsCompleted bool `json:"is_completed"` // 任务是否已完成 } // String 方法让Task在打印时更具可读性 func (t Task) String() string { status := "待办" if t.IsCompleted { status = "已完成" } return fmt.Sprintf("ID: %sn标题: %sn描述: %sn提醒时间: %sn状态: %sn", t.ID, t.Title, t.Description, t.DueTime.Format("2006-01-02 15:04:05"), status) }
这里我用了
json:"..."
的tag，这在后续进行JSON序列化和反序列化时非常有用，能让字段名在JSON中更规范。
DueTime
使用
time.Time
类型是关键，它提供了强大的时间处理能力，比如格式化、比较等。
String()
方法则是一个小小的便利，让
fmt.Println(task)
时输出更友好，而不是一堆内存地址。ID用
string
类型，可以考虑使用
uuid
库生成，确保唯一性。
Golang中如何实现任务的持久化存储？
任务的持久化存储，对于一个提醒工具来说是必不可少的。总不能每次程序重启，任务就全没了，对吧？对于小型应用，我通常会选择JSON文件作为存储介质，它简单、直观，并且Go标准库提供了非常完善的
encoding/json
包来处理。
核心思路是：将内存中的
[]Task
切片编码成JSON格式的字符串，然后写入文件；反过来，从文件读取JSON字符串，解码成
[]Task
切片。
package main import ( "encoding/json" "io/ioutil" "os" "path/filepath" ) const dataFile = "tasks.json" // saveTasks 将任务列表保存到JSON文件 func saveTasks(tasks []Task) error { data, err := json.MarshalIndent(tasks, "", " ") // 使用MarshalIndent让JSON文件更易读 if err != nil { return fmt.Errorf("序列化任务失败: %w", err) } // 确保数据文件所在的目录存在 dir := filepath.Dir(dataFile) if dir != "" && dir != "." { // 如果dataFile不是在当前目录，需要创建目录 if _, err := os.Stat(dir); os.IsNotExist(err) { if err := os.MkdirAll(dir, 0755); err != nil { return fmt.Errorf("创建数据目录失败: %w", err) } } } err = ioutil.WriteFile(dataFile, data, 0644) if err != nil { return fmt.Errorf("写入任务文件失败: %w", err) } return nil } // loadTasks 从JSON文件加载任务列表 func loadTasks() ([]Task, error) { if _, err := os.Stat(dataFile); os.IsNotExist(err) { // 文件不存在，返回空列表而不是错误 return []Task{}, nil } data, err := ioutil.ReadFile(dataFile) if err != nil { return nil, fmt.Errorf("读取任务文件失败: %w", err) } var tasks []Task err = json.Unmarshal(data, &tasks) if err != nil { return nil, fmt.Errorf("反序列化任务失败: %w", err) } return tasks, nil }
这里我用了
json.MarshalIndent
而不是
json.Marshal
，只是为了让输出的JSON文件带缩进，更方便人类阅读和调试。
ioutil.WriteFile
和
ioutil.ReadFile
是读写文件的便捷函数。在
loadTasks
时，特意检查了文件是否存在，如果不存在就返回一个空的任务列表，这样程序启动时就不会因为文件不存在而报错，用户体验会更好。
如何构建一个可靠的任务调度和提醒机制？
任务调度和提醒是这个工具的核心功能，也是最需要一点“魔法”的地方。在Golang里，实现一个简单的调度机制，其实比想象中要直接。我们主要利用
time.AfterFunc
这个函数，它可以在指定延迟后执行一个函数，非常适合单次提醒的场景。
关键在于，程序启动后，我们需要遍历所有未完成的任务，为每个任务计算出距离提醒时间还有多久，然后设置一个
time.AfterFunc
。由于
time.AfterFunc
是非阻塞的（它会在一个新的goroutine中执行你的函数），所以可以同时调度多个任务。
package main import ( "sync" "time" ) // scheduler 用于管理所有任务的调度 type Scheduler struct { tasks []Task mu sync.Mutex // 保护tasks切片的并发访问 stopChans map[string]chan struct{} // 存储每个任务的停止信号通道 } func NewScheduler(initialTasks []Task) *Scheduler { s := &Scheduler{ tasks: initialTasks, stopChans: make(map[string]chan struct{}), } return s } // ScheduleTask 为单个任务设置提醒 func (s *Scheduler) ScheduleTask(task Task) { if task.IsCompleted { return // 已完成的任务无需调度 } now := time.Now() if task.DueTime.Before(now) { // 提醒时间已过，可以直接触发提醒或标记为过期 fmt.Printf("【过期提醒】任务 '%s' (ID: %s) 提醒时间已过: %sn", task.Title, task.ID, task.DueTime.Format("15:04:05")) return } duration := task.DueTime.Sub(now) if duration <= 0 { // 避免负数或零导致time.AfterFunc立即执行 duration = time.Millisecond // 至少等待一毫秒 } stopChan := make(chan struct{}) s.mu.Lock() s.stopChans[task.ID] = stopChan // 记录停止通道，以便取消 s.mu.Unlock() fmt.Printf("【调度】任务 '%s' (ID: %s) 将在 %s 后提醒。n", task.Title, task.ID, duration.String()) go func(t Task, sc chan struct{}) { select { case <-time.After(duration): fmt.Printf("n? 【任务提醒】时间到了！n%sn", t.String()) // 提醒后，可以考虑自动标记为已完成或需要用户手动确认 // 这里为了简化，我们只打印提醒 case <-sc: fmt.Printf("【取消调度】任务 '%s' (ID: %s) 的提醒已被取消。n", t.Title, t.ID) } s.mu.Lock() delete(s.stopChans, t.ID) // 任务完成后从调度器中移除 s.mu.Unlock() }(task, stopChan) } // CancelTask 取消一个任务的提醒 func (s *Scheduler) CancelTask(taskID string) { s.mu.Lock() defer s.mu.Unlock() if ch, ok := s.stopChans[taskID]; ok { close(ch) // 发送停止信号 delete(s.stopChans, taskID) } } // StartAllTasksScheduler 启动所有任务的调度 func (s *Scheduler) StartAllTasksScheduler() { s.mu.Lock() defer s.mu.Unlock() for _, task := range s.tasks { s.ScheduleTask(task) } } // AddTaskToScheduler 添加新任务并调度 func (s *Scheduler) AddTaskToScheduler(task Task) { s.mu.Lock() s.tasks = append(s.tasks, task) s.mu.Unlock() s.ScheduleTask(task) }
这里我引入了一个
Scheduler
结构体来管理所有任务的调度，包括一个
sync.Mutex
来保证并发安全，以及一个
stopChans
映射来存储每个任务的停止信号通道，这在需要取消某个任务的提醒时非常有用。
select
语句结合
time.After
和
stopChan
，可以优雅地实现定时提醒或提前取消提醒。
需要注意的是，
time.AfterFunc
创建的定时器，如果程序退出，这些定时器也会随之消失。所以，一个真正“可靠”的提醒工具，在生产环境中，可能需要一个长期运行的后台进程，或者结合操作系统的计划任务（如Linux的cronjob，Windows的任务计划程序）来确保即使程序意外退出，也能在下次启动时重新加载并调度任务。但对于我们这个小型工具，当前这种内存调度方案已经足够演示核心概念了。
命令行交互与任务管理
一个没有用户界面的工具是孤独的。虽然是命令行，但我们仍然需要一些指令来与它互动，比如添加任务、查看任务列表、标记任务完成，或者干脆删除一个任务。这部分，通常会用到Go的
flag
包或者更高级的命令行解析库如
spf13/cobra
。
我们可以设计几个简单的命令：
-
go run main.go add -t "买菜" -d "晚上做饭用" -time "2023-10-27 18:00:00"
：添加一个新任务。
-
go run main.go list
：列出所有任务。
-
go run main.go complete -id <task-id>
：标记任务完成。
-
go run main.go delete -id <task-id>
：删除任务。
这需要我们在
main
函数中解析命令行参数，并根据参数执行相应的逻辑。例如，
main
函数可能长这样：
package main import ( "bufio" "fmt" "os" "strings" "time" "github.com/google/uuid" // 引入uuid库生成唯一ID ) var scheduler *Scheduler var tasks []Task // 全局的任务列表 func main() { // 加载现有任务 loadedTasks, err := loadTasks() if err != nil { fmt.Printf("加载任务失败: %vn", err) os.Exit(1) } tasks = loadedTasks scheduler = NewScheduler(tasks) scheduler.StartAllTasksScheduler() // 启动所有任务的调度 fmt.Println("任务提醒工具已启动。输入 'help' 查看命令。") reader := bufio.NewReader(os.Stdin) for { fmt.Print("> ") input, _ := reader.ReadString('n') input = strings.TrimSpace(input) parts := strings.Fields(input) if len(parts) == 0 { continue } command := parts[0] args := parts[1:] switch command { case "add": handleAddCommand(args) case "list": handleListCommand() case "complete": handleCompleteCommand(args) case "delete": handleDeleteCommand(args) case "help": printHelp() case "exit": fmt.Println("退出任务提醒工具。") // 在退出前保存所有任务 if err := saveTasks(tasks); err != nil { fmt.Printf("保存任务失败: %vn", err) } return default: fmt.Println("未知命令。输入 'help' 查看命令。") } } } func printHelp() { fmt.Println(` 可用命令: add <title> <description> <due_time> - 添加新任务 (due_time格式: "2006-01-02 15:04:05") list - 列出所有任务 complete <task_id> - 标记任务为已完成 delete <task_id> - 删除任务 help - 显示帮助信息 exit - 退出程序 `) } func handleAddCommand(args []string) { if len(args) < 3 { fmt.Println("用法: add <title> <description> <due_time>") return } title := args[0] description := args[1] dueTimeStr := strings.Join(args[2:], " ") // due_time可能包含空格 dueTime, err := time.Parse("2006-01-02 15:04:05", dueTimeStr) if err != nil { fmt.Printf("时间格式错误，请使用 'YYYY-MM-DD HH:MM:SS' 格式: %vn", err) return } newTask := Task{ ID: uuid.New().String(), Title: title, Description: description, DueTime: dueTime, IsCompleted: false, } tasks = append(tasks, newTask) scheduler.AddTaskToScheduler(newTask) // 添加到调度器 if err := saveTasks(tasks); err != nil { fmt.Printf("保存任务失败: %vn", err) } fmt.Printf("任务 '%s' 已添加，ID: %sn", newTask.Title, newTask.ID) } func handleListCommand() { if len(tasks) == 0 { fmt.Println("当前没有任务。") return } fmt.Println("--- 任务列表 ---") for _, task := range tasks { fmt.Println(task.String()) } fmt.Println("----------------") } func handleCompleteCommand(args []string) { if len(args) < 1 { fmt.Println("用法: complete <task_id>") return } taskID := args[0] found := false for i := range tasks { if tasks[i].ID == taskID { tasks[i].IsCompleted = true scheduler.CancelTask(taskID) // 任务完成，取消调度 found = true break } } if found { if err := saveTasks(tasks); err != nil { fmt.Printf("保存任务失败: %vn", err) } fmt.Printf("任务 '%s' 已标记为完成。n", taskID) } else { fmt.Printf("未找到ID为 '%s' 的任务。n", taskID) } } func handleDeleteCommand(args []string) { if len(args) < 1 { fmt.Println("用法: delete <task_id>") return } taskID := args[0] newTasks := []Task{} found := false for _, task := range tasks { if task.ID == taskID { found = true scheduler.CancelTask(taskID) // 删除任务，取消调度 } else { newTasks = append(newTasks, task) } } if found { tasks = newTasks if err := saveTasks(tasks); err != nil { fmt.Printf("保存任务失败: %vn", err) } fmt.Printf("任务 '%s' 已删除。n", taskID) } else { fmt.Printf("未找到ID为 '%s' 的任务。n", taskID) } }
我这里直接用了一个简单的
bufio.NewReader(os.Stdin)
来读取用户输入，并通过
strings.Fields
来分割命令和参数。这种方式虽然不如
cobra
等库强大，但对于一个“小型”且注重示例的工具来说，足够了。它能让你清晰地看到命令解析和逻辑执行的整个流程，并且在退出时，别忘了保存任务，这是持久化的最后一步。
linux js git json go windows github golang 操作系统 go语言 编码 app golang json String select 标识符 字符串 结构体 命令行参数 数据结构 堆 Go语言 切片 delete 并发 windows linux