Golang中处理JSON编解码失败时返回的错误类型有哪些

*json.SyntaxError

*json.UnmarshalTypeError

io.EOF

io.ErrUnexpectedEOF

*json.UnsupportedTypeError

*json.InvalidUTF8Error

json.Unmarshal

json.Marshal

nil

switch err := err.(type)

errors.As

json.Unmarshal

*json.SyntaxError

*json.UnmarshalTypeError

*json.SyntaxError

err.Offset

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    invalidJSON := `{"name": "Alice", "age": 30,}` // 最后一个逗号是语法错误
    var user User
    err := json.Unmarshal([]byte(invalidJSON), &user)
    if err != nil {
        if syntaxErr, ok := err.(*json.SyntaxError); ok {
            fmt.Printf("JSON语法错误，位置在偏移量 %d: %s\n", syntaxErr.Offset, syntaxErr.Error())
            // 根据业务需求，可以记录日志，或者返回一个更友好的错误信息
        } else {
            fmt.Printf("其他Unmarshal错误: %s\n", err)
        }
    }

    // 另一方面，输入为空或者不完整也可能导致错误
    emptyInput := ``
    err = json.Unmarshal([]byte(emptyInput), &user)
    if err != nil {
        if err == io.EOF { // io.EOF 需要导入 "io" 包
            fmt.Println("输入为空，无法Unmarshal")
        } else if err == io.ErrUnexpectedEOF {
            fmt.Println("输入意外结束，JSON不完整")
        } else {
            fmt.Printf("处理空输入时的其他错误: %s\n", err)
        }
    }
}

*json.UnmarshalTypeError

"age": "thirty"

Age

int

err.Field

err.Type

err.Value

package main

import (
    "encoding/json"
    "fmt"
)

type Product struct {
    ID    string  `json:"id"`
    Price float64 `json:"price"`
}

func main() {
    typeMismatchJSON := `{"id": "p001", "price": "ninety-nine"}` // price期望float64，实际是string
    var product Product
    err := json.Unmarshal([]byte(typeMismatchJSON), &product)
    if err != nil {
        if typeErr, ok := err.(*json.UnmarshalTypeError); ok {
            fmt.Printf("JSON类型不匹配错误：字段 '%s' 期望是 %s 类型，但收到了 %s 类型的值 '%s'\n",
                typeErr.Field, typeErr.Type.String(), typeErr.Value, typeErr.Value)
            // 这里可以根据typeErr.Field做更细致的业务逻辑处理
        } else {
            fmt.Printf("其他Unmarshal错误: %s\n", err)
        }
    }
}

chan

json.Marshal

*json.UnsupportedTypeError

*json.InvalidUTF8Error

*json.UnsupportedTypeError

func

chan

complex

json

err.Type

json.Marshaler

package main

import (
    "encoding/json"
    "fmt"
)

type Report struct {
    ID    string
    Data  map[string]interface{}
    // Processor func() // 如果这里有func类型，就会报错
    Channel chan int // 这是一个不支持序列化的类型
}

func main() {
    r := Report{
        ID:      "rep-001",
        Data:    map[string]interface{}{"status": "pending"},
        Channel: make(chan int),
    }

    _, err := json.Marshal(r)
    if err != nil {
        if unsupportedErr, ok := err.(*json.UnsupportedTypeError); ok {
            fmt.Printf("JSON序列化错误：不支持的类型 %s\n", unsupportedErr.Type.String())
            // 此时需要修改Report结构体，移除或替换Channel字段
        } else {
            fmt.Printf("其他Marshal错误: %s\n", err)
        }
    }

    // 另一方面，InvalidUTF8Error
    // 假设我们有一个包含无效UTF-8字符的字符串
    badString := "Hello\xc3\x28World" // 这是一个无效的UTF-8序列
    dataWithBadString := struct {
        Message string `json:"message"`
    }{
        Message: badString,
    }

    _, err = json.Marshal(dataWithBadString)
    if err != nil {
        if invalidUTF8Err, ok := err.(*json.InvalidUTF8Error); ok {
            fmt.Printf("JSON序列化错误：无效的UTF-8字符，位置在偏移量 %d\n", invalidUTF8Err.Offset)
            // 需要确保所有字符串数据都是合法的UTF-8编码
        } else {
            fmt.Printf("其他Marshal错误: %s\n", err)
        }
    }
}

*json.InvalidUTF8Error

json.Marshaler

MarshalJSON()

json.Marshal

*json.ErrorType

Unmarshal

json.Decoder

json.Encoder

Decoder.Decode()

Encoder.Encode()

io.EOF

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "strings"
)

func main() {
    jsonStream := `{"name":"Alice"}{"name":"Bob"}{"name":"Charlie"}`
    decoder := json.NewDecoder(strings.NewReader(jsonStream))

    for {
        var person struct{ Name string }
        err := decoder.Decode(&person)
        if err == io.EOF {
            fmt.Println("流读取完毕。")
            break
        }
        if err != nil {
            fmt.Printf("流式解码错误: %s\n", err)
            break
        }
        fmt.Printf("解码成功: %+v\n", person)
    }
}

json.RawMessage

json.RawMessage

package main

import (
    "encoding/json"
    "fmt"
)

type Event struct {
    ID      string          `json:"id"`
    Payload json.RawMessage `json:"payload"` // 延迟解析
}

type UserLogin struct {
    Username string `json:"username"`
    IP       string `json:"ip"`
}

func main() {
    eventJSON := `{"id": "evt-001", "payload": {"username": "go_dev", "ip": "192.168.1.1"}}`
    var event Event
    err := json.Unmarshal([]byte(eventJSON), &event)
    if err != nil {
        fmt.Printf("事件解析错误: %s\n", err)
        return
    }
    fmt.Printf("事件ID: %s\n", event.ID)

    var loginData UserLogin
    err = json.Unmarshal(event.Payload, &loginData) // 二次解析payload
    if err != nil {
        fmt.Printf("Payload解析错误: %s\n", err)
        return
    }
    fmt.Printf("用户登录信息: %+v\n", loginData)
}

encoding/json

jsoniter