欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

golang使用json格式实现增删查改

程序员文章站 2022-10-09 13:18:45
需求和思路 在一般的小项目或者一个小软件,例如客户端之类的小程序中,可能会需要数据的持久化.但是使用一般的数据库(Mysql)之类的不合适.使用sqlite3这种嵌入式的是个较好的方法,但是Go语言中sqlite3的库是C语言的,Cgo不支持跨平台编译.正是由于这种需求,才想到使用json格式将数据 ......

需求和思路

在一般的小项目或者一个小软件,例如客户端之类的小程序中,可能会需要数据的持久化.但是使用一般的数据库(mysql)之类的不合适.使用sqlite3这种嵌入式的是个较好的方法,但是go语言中sqlite3的库是c语言的,cgo不支持跨平台编译.正是由于这种需求,才想到使用json格式将数据直接保存在文件中.
具体的思路是怎么样呢? 在go语言中如果要将数据转化成json格式的话,有两种格式 struct 和 map. 如果同时需要增删查改功能的话,将map作为中间格式是比较合适的.接下来我们就来实现它.

查询操作

这种操作的实现比较简单,直接将文件中的数据读取出来,使用json库反序列化就可以了. 代码如下 :

type product struct {
    name string `json:"name"`
    num  int    `json:"num"`
}

func findall() {
    ps := make([]product, 0)

    data, err := ioutil.readfile("./index.json")
    if err != nil {
        log.fatal(err)
    }

    // 这里参数要指定为变量的地址
    err = json.unmarshal(data, &ps)
    if err != nil {
        log.fatal(err)
    }

    fmt.println(ps)
}

添加操作

添加的实现实在查询的基础上的,我们需要先查询文件中的数据库,并转化为map格式,再将struct也转化为map格式(这里要使用反射),合并map,json序列化,最后保存在文件中.代码如下:

func create() {
    fields := make([]map[string]interface{}, 0)
    
    p1 := &product{
        name: "blog",
        num:  2,
    }
    
    _, _ = json.marshal(p1)
    // 读取文件中的数据,保存为map格式
    data, _ := ioutil.readfile("./index.json")
    err := json.unmarshal(data, &fields)
    if err != nil {
        log.fatal(err)
    }
    
    // 使用反射将struct转化为map
    tp := reflect.typeof(p1).elem()
    vp := reflect.valueof(p1).elem()
    field := make(map[string]interface{}, 0)
    for i := 0; i < tp.numfield(); i++ {
        field1 := tp.field(i)
        field2 := vp.field(i)
        key := field1.tag.get("json")
        field[key] = field2.interface()
    }
    // 合并map
    fields = append(fields, field)
    
    // 写入文件
    out, _ := json.marshal(fields)
    _ = ioutil.writefile("./index.json", out, 0755)
}

条件查询

思路: 将struct转化为map,根据输入的条件查询.查询的结果转化为struct.代码如下:

func findone() {
    product := &product{}

    p1 := &product{
        name: "john",
        num:  23,
    }

    // 使用反射将struct转化为map
    tp := reflect.typeof(p1).elem()
    vp := reflect.valueof(p1).elem()
    field := make(map[string]interface{}, 0)
    for i := 0; i < tp.numfield(); i++ {
        field1 := tp.field(i)
        field2 := vp.field(i)
        key := field1.tag.get("json")
        switch field2.kind() {
        case reflect.int:
            field[key] = float64(field2.interface().(int))
        case reflect.int8:
            field[key] = float64(field2.interface().(int8))
        case reflect.int16:
            field[key] = float64(field2.interface().(int16))
        case reflect.int32:
            field[key] = float64(field2.interface().(int32))
        case reflect.int64:
            field[key] = float64(field2.interface().(int64))
        case reflect.uint:
            field[key] = float64(field2.interface().(uint))
        case reflect.uint8:
            field[key] = float64(field2.interface().(uint8))
        case reflect.uint16:
            field[key] = float64(field2.interface().(uint16))
        case reflect.uint32:
            field[key] = float64(field2.interface().(uint32))
        case reflect.uint64:
            field[key] = float64(field2.interface().(uint64))
        case reflect.float32:
            field[key] = float64(field2.interface().(float32))
        case reflect.float64:
            field[key] = field2.interface()
        default:
            field[key] = field2.interface()
        }
    }

    _, _ = json.marshal(p1)
    // 读取文件中的数据,保存为map格式
    // 数据转化为map时,数值类型的统一变成float64
    data, _ := ioutil.readfile("./index.json")
    fields := make([]map[string]interface{}, 0)
    err := json.unmarshal(data, &fields)
    if err != nil {
        log.fatal(err)
    }

    // 查询的条件
    columns := []string{"name", "num"}
    length := len(columns)
    for _, item := range fields {
        for i := 0; i < length; i++ {
            // 这里的比较需要改进
            if item[columns[i]] != field[columns[i]] {
                break
            }
            if i == length-1 {
                field = item
                goto over
            }
        }
    }
over:
    fmt.println(field)

    out, _ := json.marshal(field)
    _ = json.unmarshal(out, &product)

    fmt.println(product)
}

修改操作

修改操作在查询操作的基础上实现, 修改操作需要有一个id值,能确定元素的唯一性.代码如下:

func update() {
    p1 := &product{
        id:   "2bbec87025968879c3c9682abe3bf730",
        name: "john_e",
        num:  100,
    }

    // 使用反射将struct转化为map
    tp := reflect.typeof(p1).elem()
    vp := reflect.valueof(p1).elem()
    field := make(map[string]interface{}, 0)
    for i := 0; i < tp.numfield(); i++ {
        field1 := tp.field(i)
        field2 := vp.field(i)
        key := field1.tag.get("json")
        switch field2.kind() {
        case reflect.int:
            field[key] = float64(field2.interface().(int))
        case reflect.int8:
            field[key] = float64(field2.interface().(int8))
        case reflect.int16:
            field[key] = float64(field2.interface().(int16))
        case reflect.int32:
            field[key] = float64(field2.interface().(int32))
        case reflect.int64:
            field[key] = float64(field2.interface().(int64))
        case reflect.uint:
            field[key] = float64(field2.interface().(uint))
        case reflect.uint8:
            field[key] = float64(field2.interface().(uint8))
        case reflect.uint16:
            field[key] = float64(field2.interface().(uint16))
        case reflect.uint32:
            field[key] = float64(field2.interface().(uint32))
        case reflect.uint64:
            field[key] = float64(field2.interface().(uint64))
        case reflect.float32:
            field[key] = float64(field2.interface().(float32))
        case reflect.float64:
            field[key] = field2.interface()
        default:
            field[key] = field2.interface()
        }
    }

    _, _ = json.marshal(p1)
    // 读取文件中的数据,保存为map格式
    // 数据转化为map时,数值类型的统一变成float64
    data, _ := ioutil.readfile("./index.json")
    fields := make([]map[string]interface{}, 0)
    err := json.unmarshal(data, &fields)
    if err != nil {
        log.fatal(err)
    }

    // 修改的条件
    columns := []string{"name", "num"}
    for _, v := range fields {
        if v["_id"] == field["_id"] {
            for _, col := range columns {
                v[col] = field[col]
            }
            field = v
        }
    }

    out, _ := json.marshalindent(fields, "", "  ")
    _ = ioutil.writefile("./index.json", out, 0755)
}

删除操作

最后就是删除操作了,这个比较思路简单,输入唯一的id值,删除对应的字段,再保存到文件就可以了.代码如下:

func delete() {
    p1 := &product{
        id:   "db43fa2d4f69cddce7494941cb36032b",
        name: "john_e",
        num:  100,
    }

    _, _ = json.marshal(p1)
    // 读取文件中的数据,保存为map格式
    // 数据转化为map时,数值类型的统一变成float64
    data, _ := ioutil.readfile("./index.json")
    fields := make([]map[string]interface{}, 0)
    err := json.unmarshal(data, &fields)
    if err != nil {
        log.fatal(err)
    }

    length := len(fields)
    for index, field := range fields {
        if field["_id"] == p1.id {
            if index == length - 1 {
                fields = fields[0:index]
            } else {
                fields = append(fields[0:index], fields[index+1:]...)
            }
        }
    }

    out, _ := json.marshalindent(fields, "", "  ")
    _ = ioutil.writefile("./index.json", out, 0755)
}