Go 언어로 json 데이터를 처리하는 방법

go json bag armarshal(): GO 데이터 객체-& gt; json 데이터 Unmarshal(): json 데이터-& gt; Go 데이터 객체

func Marshal(v interface{}) ([]byte, error)
func Unmarshal(data []byte, v interface{}) error

JSON 데이터 구축

Marshal() MarshalIndent() 함수는 데이터를 json 데이터로 캡슐화할 수 있습니다. 1. struct, Slice, array, map은 모두 json으로 변환 가능2. struct를 json으로 변환할 때는 필드의 첫 글자만 변환됩니다

3. map 변환 시 키는 문자열이어야 합니다.

4. 캡슐화할 때 포인터인 경우 포인터가 가리키는 개체가 캡슐화를 위해 추적됩니다. 예:

구조체는 다음과 같습니다.

type Post struct {
    Id      int
    Content string
    Author  string
}

이 구조는 기사가 포함된 블로그 게시물 유형을 나타냅니다. ID, 기사 내용, 기사 내용을 제출합니다. 이에 대해 말할 것도 없고 지정해야 할 유일한 것은 구조체이고 구조체가 JSON 데이터로 캡슐화(인코딩)될 수 있다는 것입니다.

이 구조체 데이터를 json으로 변환하려면 Marshal()을 사용하세요. 다음과 같습니다.

post := &Post{1, "Hello World", "userA"}
b, err := json.Marshal(post)
if err != nil {
    fmt.Println(nil)
}

Marshal()은 []바이트 유형을 반환합니다. 이제 변수 b는 출력할 수 있는 []바이트 유형 json 데이터를 저장했습니다.

fmt.Println(string(b))

결과:

{"Id":1,"Content":"Hello World","Author":"userA"}

는 다음과 같이 캡슐화될 수 있습니다. json "beautifying" 시 MarshalIndent()를 사용하여 접두사(접두사 문자열은 일반적으로 비어 있음)와 들여쓰기를 자동으로 추가합니다.

c,err := json.MarshalIndent(post,"","\t")
if err != nil {
    fmt.Println(nil)
}
fmt.Println(string(c))

Result:

{
    "Id": 1,
    "Content": "Hello World",
    "Author": "userA"
}

구조체, 배열, 슬라이스 및 맵 구조 외에도 다음을 수행할 수 있습니다. json으로 파싱되지만, map이 json으로 파싱될 때 키는 json 구문에 필요한 문자열이어야 합니다.

예:

// slice -> json
s := []string{"a", "b", "c"}
d, _ := json.MarshalIndent(s, "", "\t")
fmt.Println(string(d))

// map -> json
m := map[string]string{
    "a":"aa",
    "b":"bb",
    "c":"cc",
}
e,_ := json.MarshalIndent(m,"","\t")
fmt.Println(string(e))

반환 결과:

[
    "a",
    "b",
    "c"
]
{
    "a": "aa",
    "b": "bb",
    "c": "cc"
}

구조체 태그를 사용하여 json 생성을 지원하세요

구조체로 변환할 수 있는 필드는 첫 글자가 대문자인 모든 필드이지만, 원하는 경우 json에서는 소문자를 사용하세요. 키의 경우 구조체의 태그를 사용하여 리플렉션을 지원할 수 있습니다.

예를 들어 Post 구조는 첫 글자가 소문자인 createAt 필드를 추가합니다.

type Post struct {
    Id      int      `json:"ID"`
    Content string   `json:"content"`
    Author  string   `json:"author"`
    Label   []string `json:"label"`
}


postp := &Post{
    2,
    "Hello World",
    "userB",
    []string{"linux", "shell"},
    }

p, _ := json.MarshalIndent(postp, "", "\t")
fmt.Println(string(p))

결과:

{
    "ID": 2,
    "content": "Hello World",
    "author": "userB",
    "label": [
        "linux",
        "shell"
    ]
}

구조 태그를 사용할 때 몇 가지 참고 사항:

1 태그에서 식별된 이름은 json 데이터의 키 값이라고 합니다.

2. to `json:"- "`는 필드 이름의 첫 글자가 대문자인 경우에도 이 필드가 json 데이터로 변환되지 않음을 의미합니다.

json 키의 이름을 "-" 문자로 지정하려면, `json:"-,"`를 특별히 처리할 수 있습니다. 즉, 이전 쉼표

3을 추가할 수 있습니다. 태그에 생략 옵션이 포함된 경우 이 필드의 값이 0, 즉 false, 0, " ", nil 등의 경우 이 필드는 json

4로 변환되지 않습니다. 필드 유형이 bool, string, int class, float class이고 태그에 string 옵션이 있는 경우 이 필드의 값은 다음과 같습니다. json 문자열로 변환

예:

type Post struct {
    Id      int      `json:"ID,string"`
    Content string   `json:"content"`
    Author  string   `json:"author"`
    Label   []string `json:"label,omitempty"`
}

json 데이터를 구조체로 구문 분석합니다(구조는 알려져 있음)

json 데이터는 구조체 또는 빈 인터페이스 인터페이스로 구문 분석할 수 있습니다{}(슬라이싱할 수도 있음, 지도 등). 위에서 json을 구성할 때 태그 규칙을 이해하고 나면 json을 이해하고 파싱하는 것은 매우 간단합니다.

예를 들어 다음은 json 데이터 조각입니다.

{
    "id": 1,
    "content": "hello world",
    "author": {
        "id": 2,
        "name": "userA"
    },
    "published": true,
    "label": [],
    "nextPost": null,
    "comments": [{
            "id": 3,
            "content": "good post1",
            "author": "userB"
        },
        {
            "id": 4,
            "content": "good post2",
            "author": "userC"
        }
    ]
}

이 json 데이터 조각을 분석합니다. 1 최상위 중괄호는 Go의 구조체에 매핑되는 익명 개체를 나타냅니다. struct name은 Post

2. 최상위 중괄호 안의 필드는 모두 Post 구조의 필드이므로 첫 번째 문자를 대문자로 설정해야 합니다. 3. Author는 하위 객체입니다. Mapping to Go는 Post에서 이 필드의 이름이 Author입니다.

4. 레이블은 배열입니다. Go에 매핑되면 슬라이스 또는 배열이 될 수 있으며, json 배열이 비어 있으므로 Go에서는 슬라이스/배열 유형이 가변적일 수 있습니다. 인터페이스{}의 경우 레이블은 string

5여야 하며 nextPost는 Go의 구조체에 매핑되는 하위 개체입니다. 그러나 json의 이 개체는 null이므로 이를 나타냅니다. 객체가 존재하지 않으면 Go에 매핑된 구조체 유형을 결정하는 것이 불가능합니다. 하지만 여기 예에서는 다음 기사가 없으므로 해당 유형도 Post 유형이어야 합니다

6. Comment는 하위 개체이며 Go에 매핑되고 슬라이스/배열입니다. 슬라이스/배열 유형은 구조체입니다

분석 후 그에 따라 구조체와 구조체의 태그를 쉽게 구성할 수 있습니다. 위의 분석을 바탕으로 구성된 데이터 구조는 다음과 같습니다.

type Post struct {
    ID        int64         `json:"id"`       
    Content   string        `json:"content"`  
    Author    Author        `json:"author"`   
    Published bool          `json:"published"`
    Label     []string      `json:"label"`    
    NextPost  *Post         `json:"nextPost"` 
    Comments  []*Comment    `json:"comments"` 
}

type Author struct {
    ID   int64  `json:"id"`  
    Name string `json:"name"`
}

type Comment struct {
    ID      int64  `json:"id"`     
    Content string `json:"content"`
    Author  string `json:"author"` 
}

앞서 json 데이터 구성을 소개할 때 설명한 것처럼 포인터가 추적되므로 여기서 추론한 구조체에서 포인터 유형을 사용해도 문제가 없습니다.

그러므로 이 json 데이터가 .json 파일에 저장되어 있다고 가정하고 위의 json 데이터를 Post 유형 객체로 구문 분석합니다. 코드는 다음과 같습니다:

func main() {
    // 打开json文件
    fh, err := os.Open("a.json")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer fh.Close()
    // 读取json文件，保存到jsonData中
    jsonData, err := ioutil.ReadAll(fh)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    var post Post
    // 解析json数据到post中
    err = json.Unmarshal(jsonData, &post)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(post)
}

출력 결과:

{1 hello world {2 userA} true [] <nil> [0xc042072300 0xc0420723c0]}

也许你已经感受到了，从json数据反推算struct到底有多复杂，虽然逻辑不难，但如果数据复杂一点，这是件非常恶心的事情。所以，使用别人写好的工具来自动转换吧。本文后面有推荐json到数据结构的自动转换工具。

解析json到interface(结构未知)

上面是已知json数据结构的解析方式，如果json结构是未知的或者结构可能会发生改变的情况，则解析到struct是不合理的。这时可以解析到空接口interface{}或map[string]interface{}类型上，这两种类型的结果是完全一致的。

解析到interface{}上时，Go类型和JSON类型的对应关系如下

  JSON类型             Go类型                
---------------------------------------------
JSON objects    <-->  map[string]interface{} 
JSON arrays     <-->  []interface{}          
JSON booleans   <-->  bool                   
JSON numbers    <-->  float64                
JSON strings    <-->  string                 
JSON null       <-->  nil

例如：

func main() {
    // 读取json文件
    fh, err := os.Open("a.json")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer fh.Close()
    jsonData, err := ioutil.ReadAll(fh)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    // 定义空接口接收解析后的json数据
    var unknown interface{}
    // 或：map[string]interface{} 结果是完全一样的
    err = json.Unmarshal(jsonData, &unknown)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(unknown)
}

输出结果：

map[nextPost:<nil> comments:[map[id:3 content:good post1
author:userB] map[id:4 content:good post2 author:userC]]
id:1 content:hello world author:map[id:2 name:userA] published:true label:[]]

上面将输出map结构。这是显然的，因为类型对应关系中已经说明了，json object解析到Go interface的时候，对应的是map结构。如果将上面输出的结构进行一下格式化，得到的将是类似下面的结构：

map[
    nextPost:<nil>
    comments:[
        map[
            id:3
            content:good post1
            author:userB
        ]
        map[
            id:4
            content:good post2
            author:userC
        ]
    ]
    id:1
    content:hello world
    author:map[
        id:2
        name:userA
    ]
    published:true
    label:[]
]

现在，可以从这个map中去判断类型、取得对应的值。但是如何判断类型？可以使用类型断言：

func main() {
    // 读取json数据
    fh, err := os.Open("a.json")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer fh.Close()
    jsonData, err := ioutil.ReadAll(fh)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    // 解析json数据到interface{}
    var unknown interface{}
    err = json.Unmarshal(jsonData, &unknown)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 进行断言，并switch匹配
    m := unknown.(map[string]interface{})
    for k, v := range m {
        switch vv := v.(type) {
        case string:
            fmt.Println(k, "type: string\nvalue: ", vv)
            fmt.Println("------------------")
        case float64:
            fmt.Println(k, "type: float64\nvalue: ", vv)
            fmt.Println("------------------")
        case bool:
            fmt.Println(k, "type: bool\nvalue: ", vv)
            fmt.Println("------------------")
        case map[string]interface{}:
            fmt.Println(k, "type: map[string]interface{}\nvalue: ", vv)
            for i, j := range vv {
                fmt.Println(i,": ",j)
            }
            fmt.Println("------------------")
        case []interface{}:
            fmt.Println(k, "type: []interface{}\nvalue: ", vv)
            for key, value := range vv {
                fmt.Println(key, ": ", value)
            }
            fmt.Println("------------------")
        default:
            fmt.Println(k, "type: nil\nvalue: ", vv)
            fmt.Println("------------------")
        }
    }
}

结果如下：

comments type: []interface{}
value:  [map[id:3 content:good post1 author:userB] map[author:userC id:4 content:good post2]]
0 :  map[id:3 content:good post1 author:userB]
1 :  map[id:4 content:good post2 author:userC]
------------------
id type: float64
value:  1
------------------
content type: string
value:  hello world
------------------
author type: map[string]interface{}
value:  map[id:2 name:userA]
name :  userA
id :  2
------------------
published type: bool
value:  true
------------------
label type: []interface{}
value:  []
------------------
nextPost type: nil
value:  <nil>
------------------

可见，从interface中解析非常复杂，而且可能因为嵌套结构而导致无法正确迭代遍历。这时候，可以使用第三方包simplejson，见后文。

解析、创建json流

除了可以直接解析、创建json数据，还可以处理流式数据。

1、type Decoder解码json到Go数据结构

2、ype Encoder编码Go数据结构到json

例如：

const jsonStream = `
    {"Name": "Ed", "Text": "Knock knock."}
    {"Name": "Sam", "Text": "Who's there?"}
    {"Name": "Ed", "Text": "Go fmt."}
    {"Name": "Sam", "Text": "Go fmt who?"}
    {"Name": "Ed", "Text": "Go fmt yourself!"}
`
type Message struct {
    Name, Text string
}
dec := json.NewDecoder(strings.NewReader(jsonStream))
for {
    var m Message
    if err := dec.Decode(&m); err == io.EOF {
        break
    } else if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s: %s\n", m.Name, m.Text)
}

输出：

Ed: Knock knock.
Sam: Who's there?
Ed: Go fmt.
Sam: Go fmt who?
Ed: Go fmt yourself!

再例如，从标准输入读json数据，解码后删除名为Name的元素，最后重新编码后输出到标准输出。

func main() {
    dec := json.NewDecoder(os.Stdin)
    enc := json.NewEncoder(os.Stdout)
    for {
        var v map[string]interface{}
        if err := dec.Decode(&v); err != nil {
            log.Println(err)
            return
        }
        for k := range v {
            if k != "Name" {
                delete(v, k)
            }
        }
        if err := enc.Encode(&v); err != nil {
            log.Println(err)
        }
    }
}

更多go语言知识请关注PHP中文网go语言教程栏目。

위 내용은 Go 언어로 json 데이터를 처리하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!