Golang制作简易任务提醒工具教程

本教程旨在指导开发者使用Golang构建一个简易但实用的命令行任务提醒工具。文章详细阐述了任务提醒工具的核心功能实现，包括如何使用Task结构体定义任务属性，利用JSON文件实现任务的持久化存储，以及通过time.AfterFunc函数实现定时提醒功能。教程还深入探讨了任务数据结构的设计、任务调度机制的构建，并提供了添加、查看、完成和删除任务的命令行交互示例。通过本教程，读者可以掌握使用Golang开发实用工具的基本方法，并理解任务调度与提醒的核心原理。

答案：使用Go语言实现一个命令行任务提醒工具，通过Task结构体定义任务属性，JSON文件持久化存储，time.AfterFunc实现定时提醒，程序启动时加载任务并调度，支持添加、查看、完成和删除任务。

写一个小型任务提醒工具，用Golang实现，其实并不复杂，核心在于任务的定义、存储以及一个简单的调度机制。你可以把它想象成一个命令行下的迷你版日程助理，帮你记住那些不容错过的小事。

解决方案

要实现这样一个工具，我们可以从几个关键点入手：首先是任务的数据结构，它决定了我们能记录哪些信息；接着是任务的存储，确保数据不会随着程序关闭而丢失；最后，也是最关键的，是任务的调度和提醒，让程序能在正确的时间“叫醒”你。

我的思路是，用一个Go结构体来定义任务，包含ID、标题、描述、提醒时间以及完成状态。为了简化，存储部分可以考虑使用JSON文件，读写方便，对小型数据量非常友好。至于提醒，Go的time.AfterFunc配合goroutine就能优雅地实现单次提醒，而如果需要更复杂的周期性提醒，可以考虑引入像robfig/cron这样的库，不过对于“小型”工具，我们先聚焦在基础功能上。

程序启动时，会从文件加载所有未完成的任务，然后为每个任务设置一个time.AfterFunc，当时间到达时，就打印提醒信息。用户可以通过命令行指令添加、查看、完成任务。这样，一个基本的任务提醒工具就有了雏形。

如何设计一个简洁高效的任务数据结构？

设计任务的数据结构，就像在给你的“备忘录”定规矩，得想清楚它需要记录什么。对我来说，一个任务至少得有几个基本属性：一个独一无二的标识符，方便操作；一个标题，一眼就知道是啥事；一个详细描述，记录更多上下文；当然，最重要的是提醒时间，这是提醒工具的灵魂；最后，一个状态，比如“已完成”或“待办”，管理起来才清晰。

我们可以在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: %s\n标题: %s\n描述: %s\n提醒时间: %s\n状态: %s\n",
        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) 提醒时间已过: %s\n", 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%s\n", 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 ：标记任务完成。
• go run main.go delete -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("加载任务失败: %v\n", 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("保存任务失败: %v\n", 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' 格式: %v\n", 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("保存任务失败: %v\n", err)
    }
    fmt.Printf("任务 '%s' 已添加，ID: %s\n", 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("保存任务失败: %v\n", 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("保存任务失败: %v\n", err)
        }
        fmt.Printf("任务 '%s' 已删除。\n", taskID)
    } else {
        fmt.Printf("未找到ID为 '%s' 的任务。\n", taskID)
    }
}

我这里直接用了一个简单的bufio.NewReader(os.Stdin)来读取用户输入，并通过strings.Fields来分割命令和参数。这种方式虽然不如cobra等库强大，但对于一个“小型”且注重示例的工具来说，足够了。它能让你清晰地看到命令解析和逻辑执行的整个流程，并且在退出时，别忘了保存任务，这是持久化的最后一步。

到这里，我们也就讲完了《Golang制作简易任务提醒工具教程》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！