Сторонние сериализаторы

// AccountBalance содержит анонимизированную информацию о балансе аккаунта.
type AccountBalance struct {
    AccountIdHash []byte           // хеш идентификатора пользователя
    Amounts       []CurrencyAmount // балансы в разных валютах
    IsBlocked     bool             // флаг блокировки аккаунта
}

// CurrencyAmount содержит нормированное представление баланса.
// 1.50$ -> { Amount: 150, Decimals: 2, Symbol: "$" }.
type CurrencyAmount struct {
    Amount   int64  // нормальное значение баланса
    Decimals int8   // количество цифр после запятой
    Symbol   string // идентификатор валюты
} 

type MyType struct {
    ID    int      `yaml:"id"`
    Title string   `yaml:"title,omitempty"`
    List  []string `yaml:"name,flow"`
} 

type Leaf struct {
    ID   int    `yaml:"id"`
    Name string `yaml:"name"`
}

type Tree struct {
    Owner Leaf `yaml:"owner"`
    Left  Leaf `yaml:"left,flow"`
    Right Leaf `yaml:"right,inline"`
}

var tree = Tree{
    Owner: Leaf{1, "Owner"},
    Left:  Leaf{2, "Left child"},
    Right: Leaf{3, "Right child"},
} 

package main

import (
    "fmt"

    "gopkg.in/yaml.v3"
)

type (
    AccountBalance struct {
        AccountIdHash []byte           `yaml:"account_id_hash,flow"`
        Amounts       []CurrencyAmount `yaml:"amounts,omitempty"`
        IsBlocked     bool             `yaml:"is_blocked"`
    }

    CurrencyAmount struct {
        Amount   int64  `yaml:"amount"`
        Decimals int8   `yaml:"decimals"`
        Symbol   string `yaml:"symbol"`
    }
)

func main() {
    balance := AccountBalance{
        AccountIdHash: []byte{0x10, 0x20, 0x0A, 0x0B},
        Amounts: []CurrencyAmount{
            {Amount: 1000000, Decimals: 2, Symbol: "RUB"},
            {Amount: 2510, Decimals: 2, Symbol: "USD"},
        },
        IsBlocked: true,
    }

    // преобразуем значение переменной balance в YAML-формат
    out, err := yaml.Marshal(balance)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(out))
} 

package main

import (
    "fmt"

    "github.com/pelletier/go-toml"
)

type (
    AccountBalance struct {
        AccountIdHash []byte           `toml:"account_id_hash"`
        Amounts       []CurrencyAmount `toml:"amounts,omitempty"`
        IsBlocked     bool             `toml:"is_blocked" comment:"Deprecated" commented:"true"`
    }

    CurrencyAmount struct {
        Amount   int64  `toml:"amount"`
        Decimals int8   `toml:"decimals"`
        Symbol   string `toml:"symbol"`
    }
)

func main() {
    balance := AccountBalance{
        AccountIdHash: []byte{0x10, 0x20, 0x0A, 0x0B},
        Amounts: []CurrencyAmount{
            {Amount: 1000000, Decimals: 2, Symbol: "RUB"},
            {Amount: 2510, Decimals: 2, Symbol: "USD"},
        },
        IsBlocked: true,
    }

    // преобразуем значение переменной balance в TOML-формат
    out, err := toml.Marshal(balance)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(out))
} 

// myeasyjson/myjson/myjson.go
// не забудьте запустить easyjson -all myjson.go
package myjson

type (
    AccountBalance struct {
        AccountIdHash []byte           `json:"account_id_hash,flow"`
        Amounts       []CurrencyAmount `json:"amounts,omitempty"`
        IsBlocked     bool             `json:"is_blocked"`
    }

    CurrencyAmount struct {
        Amount   int64  `json:"amount"`
        Decimals int8   `json:"decimals"`
        Symbol   string `json:"symbol"`
    }
)

// myeasyjson/main.go
package main

import (
    "fmt"
    "myeasyjson/myjson"
    "github.com/mailru/easyjson"
)

func main() {
    balance := myjson.AccountBalance{
        AccountIdHash: []byte{0x10, 0x20, 0x0A, 0x0B},
        Amounts: []myjson.CurrencyAmount{
            {Amount: 1000000, Decimals: 2, Symbol: "RUB"},
            {Amount: 2510, Decimals: 2, Symbol: "USD"},
        },
        IsBlocked: true,
    }

  // преобразуем значение переменной balance в JSON-формат
    out, err := easyjson.Marshal(balance)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(out))
} 

package myjson

//go:generate easyjson -all myjson.go
type AccountBalance struct {
        AccountIdHash []byte           `json:"account_id_hash,flow"`
        Amounts       []CurrencyAmount `json:"amounts,omitempty"`
        IsBlocked     bool             `json:"is_blocked"`
}
//... 

type S struct {
    Name    string `msg:"name"` // переопределение имени поля в представлении
    Comment string `msg:"-"`    // игнорирование поля
} 

MarshalMsg([]byte)([]byte, error) 

UnmarshalMsg([]byte)([]byte, error) 

package main

import "fmt"

//go:generate msgp

type AccountBalance struct {
    AccountIdHash []byte           `msg:"account_id_hash"`
    Amounts       []CurrencyAmount `msg:"amounts"`
    IsBlocked     bool             `msg:"is_blocked"`
}

type CurrencyAmount struct {
    Amount   int64 // здесь не будем использовать структурные теги
    Decimals int8
    Symbol   string
}

func main() {
    balance := AccountBalance{
        AccountIdHash: []byte{0x10, 0x20, 0x0A, 0x0B},
        Amounts: []CurrencyAmount{
            {Amount: 1000000, Decimals: 2, Symbol: "RUB"},
            {Amount: 2510, Decimals: 2, Symbol: "USD"},
        },
        IsBlocked: true,
    }
    // сериализуем значение переменной balance
    msgpBz, err := balance.MarshalMsg(nil)
    if err != nil {
        panic(err)
    }

    var balanceCopy AccountBalance
    // декодируем данные в переменную типа AccountBalance
    if _, err := balanceCopy.UnmarshalMsg(msgpBz); err != nil {
        panic(err)
    }

    // для сравнения выведем оригинальное и полученное значения
    fmt.Printf("balanceInit: %+v\n", balance)
    fmt.Printf("balanceCopy: %+v\n", balanceCopy)

} 

package main

import (
    "fmt"

    "github.com/golang/protobuf/proto"
)

func main() {
    balance := AccountBalance{
        AccountIdHash: []byte{0x10, 0x20, 0x0A, 0x0B},
        Amounts: []*CurrencyAmount{
            {Amount: 1000000, Decimals: 2, Symbol: "RUB"},
            {Amount: 2510, Decimals: 2, Symbol: "USD"},
        },
        IsBlocked: true,
    }

    // сериализуем значение переменной balance
    protoBz, err := proto.Marshal(&balance)
    if err != nil {
        panic(err)
    }

    var balanceCopy AccountBalance
    // декодируем данные в новую переменную
    if err := proto.Unmarshal(protoBz, &balanceCopy); err != nil {
        panic(err)
    }

    // визуально сравниваем значения переменных
    fmt.Printf("balanceInit: %s\n", balance.String())
    fmt.Printf("balanceCopy: %s\n", balanceCopy.String())
} 

type AccountBalance struct {
    state         protoimpl.MessageState
    sizeCache     protoimpl.SizeCache
    unknownFields protoimpl.UnknownFields

    AccountIdHash []byte                 `protobuf:"bytes,1,opt,name=account_id_hash,json=accountIdHash,proto3" json:"account_id_hash,omitempty"` // Go: []byte
    IsBlocked     bool                   `protobuf:"varint,2,opt,name=is_blocked,json=isBlocked,proto3" json:"is_blocked,omitempty"`              // Go: bool
    Amounts       []*CurrencyAmount      `protobuf:"bytes,3,rep,name=amounts,proto3" json:"amounts,omitempty"`                                    // Go: []CurrencyAmount
}