Golang如何构建简易备忘录程序 使用map实现内存存储功能

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
    "sync" // 用于处理并发安全，虽然这个简易版不一定马上用到，但先放着是个好习惯
)

// 备忘录存储，使用map[int]string，key是备忘录ID，value是内容。
// 这里的memos是一个全局变量，便于在不同函数间共享。
// 实际项目中，更好的做法是将其封装在一个结构体中，作为方法接收者，
// 这样更符合Go的面向对象思想，也方便管理相关状态。
var memos = make(map[int]string)
var nextID = 1 // 用于生成新的备忘录ID，从1开始
var mu sync.Mutex // 保护memos map的并发访问，防止数据竞争

// addMemo 添加一个新的备忘录。
// 接收备忘录内容作为参数，自动分配一个唯一的ID。
func addMemo(content string) {
    mu.Lock() // 在修改map前加锁
    defer mu.Unlock() // 确保锁在函数退出时释放，即使发生panic

    memos[nextID] = content
    fmt.Printf("备忘录已添加，ID: %d\n", nextID)
    nextID++ // ID递增，确保唯一性
}

// listMemos 列出所有当前存储的备忘录。
// 如果没有备忘录，会打印提示信息。
func listMemos() {
    mu.Lock() // 在读取map前加锁
    defer mu.Unlock()

    if len(memos) == 0 {
        fmt.Println("当前没有备忘录。")
        return
    }

    fmt.Println("\n--- 我的备忘录 ---")
    // 遍历map，打印ID和内容
    for id, content := range memos {
        fmt.Printf("%d: %s\n", id, content)
    }
    fmt.Println("-----------------")
}

// deleteMemo 删除指定ID的备忘录。
// 接收一个整数ID作为参数。
func deleteMemo(id int) {
    mu.Lock() // 在修改map前加锁
    defer mu.Unlock()

    // 检查ID是否存在于map中
    if _, ok := memos[id]; ok {
        delete(memos, id) // 删除指定ID的条目
        fmt.Printf("备忘录 ID %d 已删除。\n", id)
    } else {
        fmt.Printf("未找到 ID 为 %d 的备忘录。\n", id)
    }
}

func main() {
    // bufio.NewReader用于从标准输入读取用户输入
    reader := bufio.NewReader(os.Stdin)

    fmt.Println("欢迎使用简易备忘录程序！")

    // 主循环，持续接收用户命令
    for {
        fmt.Println("\n请选择操作：")
        fmt.Println("1. 添加备忘录")
        fmt.Println("2. 查看所有备忘录")
        fmt.Println("3. 删除备忘录")
        fmt.Println("4. 退出")
        fmt.Print("输入你的选择: ")

        // 读取用户输入，并去除首尾空白符（包括换行符）
        input, _ := reader.ReadString('\n')
        choice := strings.TrimSpace(input)

        // 根据用户选择执行不同操作
        switch choice {
        case "1":
            fmt.Print("请输入备忘录内容: ")
            content, _ := reader.ReadString('\n')
            addMemo(strings.TrimSpace(content)) // 调用添加备忘录函数
        case "2":
            listMemos() // 调用查看备忘录函数
        case "3":
            fmt.Print("请输入要删除的备忘录ID: ")
            idStr, _ := reader.ReadString('\n')
            // 将字符串ID转换为整数
            id, err := strconv.Atoi(strings.TrimSpace(idStr))
            if err != nil {
                fmt.Println("无效的ID，请输入数字。")
                continue // 发生错误时跳过当前循环，重新显示菜单
            }
            deleteMemo(id) // 调用删除备忘录函数
        case "4":
            fmt.Println("感谢使用，再见！")
            return // 退出程序
        default:
            fmt.Println("无效的选择，请重新输入。")
        }
    }
}

make(map[keyType]valueType)

sync

sync.Mutex

sync.RWMutex

sync.Mutex

sync.Mutex

sync.RWMutex

// 示例：使用sync.RWMutex保护map，并将其封装在结构体中
type MemoStore struct {
    memos map[int]string
    mu    sync.RWMutex // 读写锁
    nextID int
}

// NewMemoStore 创建并返回一个新的MemoStore实例
func NewMemoStore() *MemoStore {
    return &MemoStore{
        memos:  make(map[int]string),
        nextID: 1,
    }
}

// AddMemo 添加备忘录，这是一个MemoStore的方法
func (s *MemoStore) AddMemo(content string) int {
    s.mu.Lock() // 写操作使用写锁
    defer s.mu.Unlock()

    id := s.nextID
    s.memos[id] = content
    s.nextID++
    return id
}

// ListMemos 列出备忘录，这是一个MemoStore的方法
func (s *MemoStore) ListMemos() map[int]string {
    s.mu.RLock() // 读操作使用读锁
    defer s.mu.RUnlock()

    // 返回一个副本，避免外部直接修改内部map，这是个好习惯
    copiedMemos := make(map[int]string, len(s.memos))
    for id, content := range s.memos {
        copiedMemos[id] = content
    }
    return copiedMemos
}

// DeleteMemo 删除备忘录，这也是一个MemoStore的方法
func (s *MemoStore) DeleteMemo(id int) bool {
    s.mu.Lock()
    defer s.mu.Unlock()

    if _, ok := s.memos[id]; ok {
        delete(s.memos, id