如何序列化和反序列化 go 中的错误字符串

Question

In the context of two go services sharing the same types, one client post a json to a server:

type Message struct {
   Error string `json:"error"`
}

The client should serialize an error into a string.

The server should deserialize that string into an error on which I can use errors.As or errors.Is to check for wrapped errors and such.

How may I serialize nested errors?

Answer 1

Let me share with you some thoughts that maybe can guide you in the right direction.

errors.Is and errors.As

These two operators deal with the error type. The common scenario they are used when you've to deal with an error returned by a function and, based on which type of error it is, take some actions. If you're returning just a string from a function, it's almost impossible to invoke errors.Is and errors.As unless you do some extra logic to handle the string.

A simple workaround

If you wanna preserve a hierarchical structure for your errors without having to flatten them, you could follow this approach:

package main

import (
    "encoding/json"
    "fmt"
)

type RecursiveErr struct {
    Message string `json:"Message"`
    Err     error  `json:"error"`
}

func (r RecursiveErr) Error() string {
    return r.Message
}

func main() {
    // recursive - marshal
    childErr := RecursiveErr{Message: "leaf-child error"}
    parentErr := RecursiveErr{Message: "root error", Err: &childErr}
    data, _ := json.MarshalIndent(&parentErr, "", "\t")
    fmt.Println(string(data))

    // recursive - unmarshal
    var parsedParentErr RecursiveErr
    json.Unmarshal(data, &parsedParentErr)
    fmt.Println(parsedParentErr.Message)
}

This solution has the following benefits:

1. You can preserve the hierarchical structure of your errors (parent-child relationship)
2. You can invoke the errors.Is and errors.As on the Err field.

As it's an uncommon scenario for me, I hope to not be off-topic with your request, let me know!