嘿，作为Go语言初学者碰到这种CLI状态管理的问题太正常了！我当初刚上手做这类工具的时候，也在JSON文件的读写和对象操作上踩了不少坑，给你分享一套实用的解决方案，一步步来应该能帮你理顺思路。

其实用JSON/YAML完全可行，关键是要把读文件-修改数据-写回文件这个流程封装成可复用的函数，避免重复代码，同时让业务逻辑更清晰。

第一步：先定义清晰的数据结构 #

首先得把你要管理的对象（比如你提到的server）用Go结构体描述出来，记得加上JSON标签方便序列化/反序列化：

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

// Server 定义你要管理的对象，Metadata用来存灵活的属性键值对
type Server struct {
    ID       string            `json:"id"`       // 唯一ID，是后续增删改的核心标识
    Name     string            `json:"name"`
    Host     string            `json:"host"`
    Metadata map[string]string `json:"metadata"` // 支持动态添加属性
}

// Storage 根结构，用来存储整个对象列表
type Storage struct {
    Servers []Server `json:"servers"`
}

第二步：封装文件读写的基础函数 #

每次操作都要先读文件加载数据，修改后再写回去，把这两步封装成函数，避免重复造轮子：

// loadStorage 从指定文件加载存储数据，文件不存在则返回空结构
func loadStorage(filePath string) (*Storage, error) {
    file, err := os.Open(filePath)
    if err != nil {
        if os.IsNotExist(err) {
            return &Storage{}, nil // 文件不存在，初始化空存储
        }
        return nil, fmt.Errorf("failed to open file: %w", err)
    }
    defer file.Close()

    var storage Storage
    decoder := json.NewDecoder(file)
    if err := decoder.Decode(&storage); err != nil {
        return nil, fmt.Errorf("failed to decode JSON: %w", err)
    }
    return &storage, nil
}

// saveStorage 将修改后的存储数据写入文件，格式化输出方便阅读
func saveStorage(filePath string, storage *Storage) error {
    file, err := os.Create(filePath)
    if err != nil {
        return fmt.Errorf("failed to create file: %w", err)
    }
    defer file.Close()

    encoder := json.NewEncoder(file)
    encoder.SetIndent("", "  ") // 生成带缩进的JSON，方便手动查看
    return encoder.Encode(storage)
}

第三步：实现增删改核心操作 #

有了基础的读写函数，就可以基于它实现具体的业务操作了：

添加对象及属性 #

// addServer 添加新的Server，会先检查ID是否重复
func addServer(filePath string, server Server) error {
    storage, err := loadStorage(filePath)
    if err != nil {
        return err
    }

    // 检查ID是否已存在，避免重复添加
    for _, s := range storage.Servers {
        if s.ID == server.ID {
            return fmt.Errorf("server with ID %s already exists", server.ID)
        }
    }

    // 初始化Metadata（如果传入的是空的话）
    if server.Metadata == nil {
        server.Metadata = make(map[string]string)
    }

    storage.Servers = append(storage.Servers, server)
    return saveStorage(filePath, storage)
}

更新对象或属性 #

支持全量更新或部分属性更新，比如只改Host或者添加Metadata：

// updateServer 根据ID更新Server的属性，支持灵活修改
func updateServer(filePath string, id string, updates map[string]interface{}) error {
    storage, err := loadStorage(filePath)
    if err != nil {
        return err
    }

    found := false
    for i := range storage.Servers {
        if storage.Servers[i].ID == id {
            // 按需更新各个字段
            if name, ok := updates["name"].(string); ok {
                storage.Servers[i].Name = name
            }
            if host, ok := updates["host"].(string); ok {
                storage.Servers[i].Host = host
            }
            // 更新Metadata属性
            if meta, ok := updates["metadata"].(map[string]string); ok {
                for k, v := range meta {
                    storage.Servers[i].Metadata[k] = v
                }
            }
            found = true
            break
        }
    }

    if !found {
        return fmt.Errorf("server with ID %s not found", id)
    }

    return saveStorage(filePath, storage)
}

删除对象 #

// deleteServer 根据ID删除指定的Server
func deleteServer(filePath string, id string) error {
    storage, err := loadStorage(filePath)
    if err != nil {
        return err
    }

    // 过滤掉要删除的对象
    newServers := make([]Server, 0, len(storage.Servers))
    for _, s := range storage.Servers {
        if s.ID != id {
            newServers = append(newServers, s)
        }
    }

    storage.Servers = newServers
    return saveStorage(filePath, storage)
}

第四步：对接CLI命令 #

最后把这些函数和CLI命令绑定，用Go标准库的flag包就能实现简单的命令解析，要是你的CLI逻辑复杂，也可以用cobra库（更专业的CLI框架）：

func main() {
    // 定义各个子命令
    addCmd := flag.NewFlagSet("add", flag.ExitOnError)
    addID := addCmd.String("id", "", "Server ID (required)")
    addName := addCmd.String("name", "", "Server name")
    addHost := addCmd.String("host", "", "Server host")

    updateCmd := flag.NewFlagSet("update", flag.ExitOnError)
    updateID := updateCmd.String("id", "", "Server ID (required)")
    updateName := updateCmd.String("name", "", "New server name")
    updateHost := updateCmd.String("host", "", "New server host")

    deleteCmd := flag.NewFlagSet("delete", flag.ExitOnError)
    deleteID := deleteCmd.String("id", "", "Server ID (required)")

    if len(os.Args) < 2 {
        fmt.Println("Usage: ./your-cli [add|update|delete]")
        os.Exit(1)
    }

    // 处理不同命令
    switch os.Args[1] {
    case "add":
        addCmd.Parse(os.Args[2:])
        if *addID == "" {
            fmt.Println("Error: --id is required for 'add' command")
            os.Exit(1)
        }
        server := Server{
            ID:       *addID,
            Name:     *addName,
            Host:     *addHost,
            Metadata: make(map[string]string),
        }
        if err := addServer("servers.json", server); err != nil {
            fmt.Printf("Error adding server: %v\n", err)
            os.Exit(1)
        }
        fmt.Println("Server added successfully!")

    case "update":
        updateCmd.Parse(os.Args[2:])
        if *updateID == "" {
            fmt.Println("Error: --id is required for 'update' command")
            os.Exit(1)
        }
        updates := make(map[string]interface{})
        if *updateName != "" {
            updates["name"] = *updateName
        }
        if *updateHost != "" {
            updates["host"] = *updateHost
        }
        // 这里可以扩展支持传入Metadata，比如用--meta key=value的形式
        if err := updateServer("servers.json", *updateID, updates); err != nil {
            fmt.Printf("Error updating server: %v\n", err)
            os.Exit(1)
        }
        fmt.Println("Server updated successfully!")

    case "delete":
        deleteCmd.Parse(os.Args[2:])
        if *deleteID == "" {
            fmt.Println("Error: --id is required for 'delete' command")
            os.Exit(1)
        }
        if err := deleteServer("servers.json", *deleteID); err != nil {
            fmt.Printf("Error deleting server: %v\n", err)
            os.Exit(1)
        }
        fmt.Println("Server deleted successfully!")

    default:
        fmt.Println("Usage: ./your-cli [add|update|delete]")
        os.Exit(1)
    }
}

一些实用小贴士 #

• 用唯一ID做标识：这是增删改操作的核心，避免因为名称重复导致操作错误
• 处理并发问题：如果是单用户使用的CLI，基本不用考虑；如果要支持多用户操作，可以加文件锁
• 切换YAML格式：要是更喜欢YAML，只需要把JSON标签换成YAML标签，用gopkg.in/yaml.v3库，读写逻辑和上面几乎一样
• 错误提示要友好：把错误信息明确说清楚，比如“ID重复”“对象不存在”，方便用户排查问题

内容的提问来源于stack exchange，提问作者Tony Stark