Golang实现小型任务提醒工具实例

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

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

解决方案

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

我的思路是，用一个Go结构体来定义任务，包含ID、标题、描述、提醒时间以及完成状态。为了简化，存储部分可以考虑使用JSON文件，读写方便，对小型数据量非常友好。至于提醒，Go的

time.AfterFunc

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: %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:"..."

DueTime

time.Time

String()

fmt.Println(task)

string

uuid

Golang中如何实现任务的持久化存储？

任务的持久化存储，对于一个提醒工具来说是必不可少的。总不能每次程序重启，任务就全没了，对吧？对于小型应用，我通常会选择JSON文件作为存储介质，它简单、直观，并且Go标准库提供了非常完善的

encoding/json

核心思路是：将内存中的

[]Task

[]Task

千图设计室AI海报

千图网旗下的智能海报在线设计平台

下载

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

ioutil.WriteFile

ioutil.ReadFile

loadTasks

如何构建一个可靠的任务调度和提醒机制？

任务调度和提醒是这个工具的核心功能，也是最需要一点“魔法”的地方。在Golang里，实现一个简单的调度机制，其实比想象中要直接。我们主要利用

time.AfterFunc

关键在于，程序启动后，我们需要遍历所有未完成的任务，为每个任务计算出距离提醒时间还有多久，然后设置一个

time.AfterFunc

time.AfterFunc

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

命令行交互与任务管理

一个没有用户界面的工具是孤独的。虽然是命令行，但我们仍然需要一些指令来与它互动，比如添加任务、查看任务列表、标记任务完成，或者干脆删除一个任务。这部分，通常会用到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