golangベースjsonシーケンス化、逆シーケンス化、errorをカスタマイズする方法

最近の作業では、構造体のネストとシーケンス化に関する問題が用いられているので、ここで整理する.構造体回転json

package main

import (
    "fmt"
    "encoding/json"
)
type User struct {
    UserName string `json:"username"`
    NickName string `json:"nickname"`
    Age      int
    Birthday string
    Sex      string
    Email    string
    Phone    string
}
/*    json--------*/
func testStruct() {
    user1 := &User{
        UserName: "user1",
        NickName: "    ",
        Age:      18,
        Birthday: "2008/8/8",
        Sex:      " ",
        Email:    "[email protected]",
        Phone:    "110",
    }

    data, err := json.Marshal(user1)
    if err != nil {
        fmt.Printf("json.marshal failed, err:", err)
        return
    }

    fmt.Printf("%s
", string(data))
}

func main() {
    testStruct()
    fmt.Println("----")
}

2.map回転json

package main

import (

    "fmt"
    "encoding/json"

)

type User struct {
    UserName string `json:"username"`
    NickName string `json:"nickname"`
    Age      int
    Birthday string
    Sex      string
    Email    string
    Phone    string
}
/*map json*/

func testMap() {
    var mmp  map[string]interface{}
    mmp = make(map[string]interface{})

    mmp["username"] = "user"
    mmp["age"] = 19
    mmp["sex"] = "man"

    data,err := json.Marshal(mmp)
    if err != nil{
        fmt.Println("json marshal failed,err:",err)
        return
    }
    fmt.Println("%s
",string(data))
}

func main() {
    testMap()
    fmt.Println("----")
}

3.int回転json

package main

import (

    "fmt"
    "encoding/json"
)
type User struct {
    UserName string `json:"username"`
    NickName string `json:"nickname"`
    Age      int
    Birthday string
    Sex      string
    Email    string
    Phone    string
}
/*slice json*/

func testSlice() {
}
func testInt() {
    var age = 100
    data, err := json.Marshal(age)
    if err != nil {
        fmt.Printf("json.marshal failed, err:", err)
        return
    }
    fmt.Printf("%s
", string(data))
}
func main() {
    testSlice()
    testInt()
    fmt.Println("----")
}

4.slice回転json

package main

import (

    "fmt"
    "encoding/json"
)
func testSlice() {
    var m map[string]interface{}
    var s []map[string]interface{}
    m = make(map[string]interface{})
    m["username"] = "user1"
    m["age"] = 18
    m["sex"] = "man"

    s = append(s, m)

    m = make(map[string]interface{})
    m["username"] = "user2"
    m["age"] = 29
    m["sex"] = "female"
    s = append(s, m)

    data, err := json.Marshal(s)
    if err != nil {
        fmt.Printf("json.marshal failed, err:", err)
        return
    }

    fmt.Printf("%s
", string(data))
}

func main() {
    testSlice()
}

5.jsonを構造体に逆シーケンス化

package main

import (
    "encoding/json"
    "fmt"
)
type User struct {
    UserName string `json:"username"`
    NickName string `json:"nickname"`
    Age      int
    Birthday string
    Sex      string
    Email    string
    Phone    string
}

func testStruct() (ret string, err error) {
    user1 := &User{
        UserName: "user1",
        NickName: "    ",
        Age:      18,
        Birthday: "2008/8/8",
        Sex:      " ",
        Email:    "[email protected]",
        Phone:    "110",
    }

    data, err := json.Marshal(user1)
    if err != nil {
        err = fmt.Errorf("json.marshal failed, err:", err)
        return
    }

    ret = string(data)
    return
}

func test() {
    data, err := testStruct()
    if err != nil {
        fmt.Println("test struct failed, ", err)
        return
    }

    var user1 User
    err = json.Unmarshal([]byte(data), &user1)
    if err != nil {
        fmt.Println("Unmarshal failed, ", err)
        return
    }
    fmt.Println(user1)
}

func main() {
    test()
    // test2()
}

6.json逆シーケンス化map

package main

import (
    "encoding/json"
    "fmt"
)


func testMap() (ret string, err error) {
    var m map[string]interface{}
    m = make(map[string]interface{})
    m["username"] = "user1"
    m["age"] = 18
    m["sex"] = "man"

    data, err := json.Marshal(m)
    if err != nil {
        err = fmt.Errorf("json.marshal failed, err:", err)
        return
    }

    ret = string(data)
    return
}

func test2() {
    data, err := testMap()
    if err != nil {
        fmt.Println("test map failed, ", err)
        return
    }

    var m map[string]interface{}
    err = json.Unmarshal([]byte(data), &m)
    if err != nil {
        fmt.Println("Unmarshal failed, ", err)
        return
    }
    fmt.Println(m)
}
f
unc main() {
    test2()
}

7.カスタムerror

package main

import (
    "fmt"
    "os"
    "time"
)

type PathError struct {
    path       string
    op         string
    createTime string
    message    string
}

func (p *PathError) Error() string {
    return fmt.Sprintf("path=%s op=%s createTime=%s message=%s", p.path,
        p.op, p.createTime, p.message)
}
/*
type error interface {
    Error() string
}
*/
func Open(filename string) error {

    file, err := os.Open(filename)
    if err != nil {
        return &PathError{
            path:       filename,
            op:         "read",
            message:    err.Error(),
            createTime: fmt.Sprintf("%v", time.Now()),
        }
    }

    defer file.Close()
    return nil
}

func main() {
    err := Open("C:/sdklflakfljdsafjs.txt")
    switch v := err.(type) {
    case *PathError:
        fmt.Println("get path error,", v)
    default:
    }
}

皆さんのご指導を歓迎して、交流して勉強します.