Go言語 big.Int と GobDecode：実践的なコード例で学ぶデータ永続化

2025-06-01

big.Int.GobDecode()は、Go言語のencoding/gobパッケージが提供するGobDecoderインターフェースをmath/big.Int型が実装しているメソッドです。

Gob (Go Binary) とは、Go言語が提供するバイナリシリアライゼーション（直列化）フォーマットです。Goの構造体や基本的な型を、ネットワーク経由で送信したり、ファイルに保存したりするために、バイナリ形式に変換（エンコード）したり、バイナリ形式から元のデータに戻す（デコード）ために使われます。

GobDecoderインターフェースは、GobDecode([]byte) errorというシグネチャを持つメソッドを定義しており、このメソッドを実装することで、その型がGob形式のバイト列から自身をデコードできることを示します。

つまり、big.Int.GobDecode()は、Gob形式でエンコードされた多倍長整数（big.Int）のバイト列を受け取り、それを現在のbig.Intインスタンスにデコードして値を設定するためのメソッドです。

使用目的

big.Int.GobDecode()は、主に以下のシナリオで使われます。

ネットワーク通信: 別のGoプログラムやサービスにbig.Intの値を送信し、受信側でそれを復元する場合。
永続化: big.Intの値をファイルやデータベースにバイナリ形式で保存し、後で読み込んで復元する場合。

big.IntはGoの組み込み整数型（int, int64など）では表現できないような、非常に大きな整数を扱うための型です。これらの大きな整数を効率的かつ正確にシリアライズ・デシリアライズするために、GobEncode()とGobDecode()が提供されています。

どのように機能するか

GobDecode()メソッドは、引数としてGob形式でエンコードされたバイトスライス（buf []byte）を受け取ります。このバイトスライスは、通常、対応するbig.Int.GobEncode()メソッドによって生成されたものです。

GobDecode()は、このバイトスライスを解析し、その中に含まれる多倍長整数の情報（符号や各桁の値など）を読み取り、レシーバである*big.Intの値を上書きします。デコード中にエラーが発生した場合は、errorを返します。

直接GobDecode()を呼び出すことは稀で、通常はencoding/gobパッケージのDecoderを通じて間接的に呼び出されます。

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"math/big"
)

func main() {
	// 元の big.Int
	originalInt := new(big.Int)
	originalInt.SetString("123456789012345678901234567890", 10)
	fmt.Printf("Original Int: %s\n", originalInt.String())

	// Gobエンコーダを作成し、originalIntをエンコード
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	err := enc.Encode(originalInt)
	if err != nil {
		fmt.Println("Encode error:", err)
		return
	}
	fmt.Printf("Encoded bytes (length): %d\n", buf.Len())

	// Gobデコーダを作成し、デコードする big.Int を準備
	decodedInt := new(big.Int)
	dec := gob.NewDecoder(&buf)

	// GobDecode() が内部的に呼び出される
	err = dec.Decode(decodedInt)
	if err != nil {
		fmt.Println("Decode error:", err)
		return
	}
	fmt.Printf("Decoded Int: %s\n", decodedInt.String())

	// 元のIntとデコードされたIntが同じであることを確認
	if originalInt.Cmp(decodedInt) == 0 {
		fmt.Println("Original and Decoded integers are identical.")
	} else {
		fmt.Println("Error: Original and Decoded integers differ.")
	}
}

gob: type not registered for decoding (型が登録されていないエラー)

これは最も一般的なエラーの一つです。gobエンコーダとデコーダは、送信・受信するGoの型を事前に認識している必要があります。特に、カスタム型や構造体が含まれる場合、gob.Register()を使って型を登録する必要があります。big.Int自体はGoの標準ライブラリの一部なので、通常は登録不要ですが、big.Intを含むカスタム構造体をGobでエンコード/デコードしようとする場合にこのエラーが発生しやすいです。

発生例

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"math/big"
)

type MyData struct {
	ID   int
	Value *big.Int // big.Int を含むカスタム構造体
}

func main() {
	// 元のデータ
	originalData := MyData{
		ID:    1,
		Value: big.NewInt(1234567890),
	}

	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	err := enc.Encode(originalData)
	if err != nil {
		fmt.Println("Encode error:", err)
		return
	}

	// デコード時に MyData 型を登録していない場合、エラーが発生する可能性がある
	var decodedData MyData
	dec := gob.NewDecoder(&buf)
	err = dec.Decode(&decodedData) // ここでエラー
	if err != nil {
		fmt.Println("Decode error:", err) // gob: type not registered for decoding...
		return
	}

	fmt.Printf("Decoded ID: %d, Value: %s\n", decodedData.ID, decodedData.Value.String())
}

トラブルシューティング

gob.Register()を使って、Gobでエンコード/デコードするすべてのカスタム型（この場合はMyData）を登録します。通常はmain関数の先頭やinit()関数で行います。

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"math/big"
)

type MyData struct {
	ID    int
	Value *big.Int
}

func init() {
	// MyData 型をGobに登録
	gob.Register(MyData{})
	// big.Int 型を登録することも推奨される場合があるが、
	// big.Intは標準ライブラリの特別な型なので通常は不要。
	// gob.Register(&big.Int{})
}

func main() {
	originalData := MyData{
		ID:    1,
		Value: big.NewInt(1234567890),
	}

	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	err := enc.Encode(originalData)
	if err != nil {
		fmt.Println("Encode error:", err)
		return
	}

	var decodedData MyData
	dec := gob.NewDecoder(&buf)
	err = dec.Decode(&decodedData)
	if err != nil {
		fmt.Println("Decode error:", err)
		return
	}

	fmt.Printf("Decoded ID: %d, Value: %s\n", decodedData.ID, decodedData.Value.String())
}

gob: decoding zero-length big.Int (ゼロ長のbig.Intをデコードしようとしている)

このエラーは、big.IntがGobエンコードされた際に空（ゼロ長）のバイト列になってしまっているか、デコードしようとしているバッファが空である場合に発生します。これは通常、エンコード段階での問題が原因です。

発生例

エンコードされたバイト列が正しくストリームに書き込まれていない、またはデコード時に誤ったバイト列を読もうとしている場合。
エンコード時にbig.Intがnilだったが、GobEncodeが期待通りに空のバイト列を生成しなかった場合（稀）。

トラブルシューティング

big.Intの初期化
デコード先のbig.Intポインタがnilでないことを確認します（ただし、gob.Decodeはnilポインタでもデコードを試みるが、値が設定されない可能性があるため、new(big.Int)などで初期化しておくのが安全）。
バイトストリームの整合性
エンコードされたバイトストリームが、デコードされる側に完全に転送されているか確認します。特にネットワーク経由の場合、データの途切れや破損がないか確認します。
エンコード側の確認
big.Intをエンコードする前に、その値が期待通りに設定されているか確認してください。nilポインタのbig.Intをエンコードしようとしていないかチェックします。

データ形式の不一致 (GobDecodeが不正なバイト列を受け取る)

これは、エンコードされたデータがGob形式として有効でないか、またはbig.IntのGob表現として正しくない場合に発生します。

発生例

エンコード側とデコード側でGoのバージョンが異なり、Gobの内部表現に微妙な差異がある（非常に稀）。
データ転送中にバイト列が破損した。
Gobではない他のシリアライゼーション形式（JSON, Protocol Buffersなど）でエンコードされたデータをGobデコーダでデコードしようとした。

トラブルシューティング

デバッグログ
エンコードされたバイト列をログに出力し、手動で検証してみる（ただし、Gobはバイナリなので人間が読むのは難しい）。
データ転送の確認
ネットワーク通信やファイルI/Oの場合、データの完全性を検証するチェックサムなどを導入することを検討してください。
エンコーダとデコーダの統一
必ず同じencoding/gobパッケージを使ってエンコードとデコードを行ってください。

big.Intのポインタと値の扱い

big.Intは常にポインタとして扱われるべきです。new(big.Int)で初期化し、ポインタとしてEncode()やDecode()に渡すのが正しい方法です。

間違いやすい例

// このように直接 big.Int の値を扱うのは一般的ではない
// func Encode(e *Encoder, data interface{}) error
// func Decode(d *Decoder, data interface{}) error
// はインターフェースを受け取るため、&variable の形式で渡すのが基本
// var myInt big.Int
// enc.Encode(myInt) // これはエンコードできるが、デコードで問題になることがある
// dec.Decode(myInt) // これはNG。ポインタでないためデコードされない

トラブルシューティング

gob.Encode()やgob.Decode()に渡す際も、そのポインタを渡してください。
big.Intを扱う際は、常にnew(big.Int)で初期化し、ポインタとして変数に格納してください。

*big.Int型のフィールドがnilの場合、GobEncode()はそのnil状態を正しくエンコードします。GobDecode()は、そのフィールドをnilとしてデコードします。

例

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"math/big"
)

type MyDataNil struct {
	ID    int
	Value *big.Int // nil の可能性がある
}

func init() {
	gob.Register(MyDataNil{})
}

func main() {
	originalData := MyDataNil{
		ID:    2,
		Value: nil, // big.Int が nil
	}

	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	err := enc.Encode(originalData)
	if err != nil {
		fmt.Println("Encode error:", err)
		return
	}

	var decodedData MyDataNil
	dec := gob.NewDecoder(&buf)
	err = dec.Decode(&decodedData)
	if err != nil {
		fmt.Println("Decode error:", err)
		return
	}

	fmt.Printf("Decoded ID: %d, Value is nil: %t\n", decodedData.ID, decodedData.Value == nil)
}

トラブルシューティング

デコード後にbig.Intがnilになることを考慮し、アプリケーションロジックでnilチェックを行う必要があります。

if decodedData.Value == nil {
    fmt.Println("Value was nil after decoding.")
} else {
    fmt.Println("Value:", decodedData.Value.String())
}

例1: 単一の `big.Int` のエンコードとデコード

最も基本的な例として、big.Int型の値をGob形式でエンコードし、その後デコードして復元するプロセスを示します。

package main

import (
	"bytes"        // バイト列をメモリ上で扱うためのパッケージ
	"encoding/gob" // Gobエンコード/デコードを行うためのパッケージ
	"fmt"          // フォーマットされた出力を行うためのパッケージ
	"math/big"     // 任意精度整数を扱うためのパッケージ
)

func main() {
	// 1. 元の big.Int を作成
	// big.NewInt() で新しい big.Int インスタンスを作成し、値を設定します。
	// ここでは非常に大きな数を文字列で指定しています。
	originalInt := new(big.Int)
	originalInt.SetString("9876543210987654321098765432109876543210", 10)
	fmt.Printf("元の big.Int: %s (型: %T)\n", originalInt.String(), originalInt)

	// 2. エンコード先のバッファを準備
	// bytes.Buffer は、メモリ上でバイト列を読み書きするための可変バッファです。
	// Gobエンコーダの出力先として使います。
	var network bytes.Buffer

	// 3. Gobエンコーダを作成
	// gob.NewEncoder() は、指定された io.Writer (ここでは &network) にGob形式でデータを書き込むエンコーダを作成します。
	enc := gob.NewEncoder(&network)

	// 4. big.Int をエンコード
	// enc.Encode() は、Goの値 (originalInt) をGob形式に変換し、エンコーダの出力先 (networkバッファ) に書き込みます。
	// この際、originalInt の GobEncode() メソッドが内部的に呼び出されます。
	err := enc.Encode(originalInt)
	if err != nil {
		fmt.Printf("エンコードエラー: %v\n", err)
		return
	}
	fmt.Printf("エンコードされたバイト列の長さ: %dバイト\n", network.Len())
	// fmt.Printf("エンコードされたバイト列: %x\n", network.Bytes()) // バイナリなので通常は表示しない

	// 5. デコード先の big.Int を準備
	// デコードされた値を格納するための新しい big.Int インスタンスを作成します。
	// ここでは new(big.Int) を使っていますが、これは既存の big.Int にデコードすることも可能です。
	decodedInt := new(big.Int)

	// 6. Gobデコーダを作成
	// gob.NewDecoder() は、指定された io.Reader (ここでは &network) からGob形式のデータを読み込むデコーダを作成します。
	// networkバッファは、先ほどエンコードされたデータを含んでいます。
	dec := gob.NewDecoder(&network)

	// 7. big.Int をデコード
	// dec.Decode() は、デコーダの入力元 (networkバッファ) からGob形式のデータを読み込み、
	// 指定されたGoの変数 (decodedInt) に復元します。
	// この際、decodedInt の GobDecode() メソッドが内部的に呼び出されます。
	err = dec.Decode(decodedInt)
	if err != nil {
		fmt.Printf("デコードエラー: %v\n", err)
		return
	}
	fmt.Printf("デコードされた big.Int: %s (型: %T)\n", decodedInt.String(), decodedInt)

	// 8. 元の big.Int とデコードされた big.Int を比較して確認
	if originalInt.Cmp(decodedInt) == 0 { // Cmp() メソッドで2つの big.Int を比較
		fmt.Println("成功: 元の big.Int とデコードされた big.Int は一致します。")
	} else {
		fmt.Println("エラー: 元の big.Int とデコードされた big.Int は一致しません。")
	}
}

実行結果例

元の big.Int: 9876543210987654321098765432109876543210 (型: *math.Int)
エンコードされたバイト列の長さ: 44バイト
デコードされた big.Int: 9876543210987654321098765432109876543210 (型: *math.Int)
成功: 元の big.Int とデコードされた big.Int は一致します。

例2: `big.Int` を含むカスタム構造体のエンコードとデコード

big.Intが他のデータと共にカスタム構造体に含まれる場合の例です。この場合、カスタム構造体をgob.Register()で登録する必要があります。

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"math/big"
)

// MyCustomData は big.Int を含むカスタム構造体です。
type MyCustomData struct {
	ID        int        // データの識別子
	Name      string     // 名前
	BigNumber *big.Int   // 非常に大きな数
	IsActive  bool       // アクティブ状態
}

// init 関数は main 関数が実行される前に自動的に呼び出されます。
// ここで Gob に MyCustomData 型を登録します。
// これがないと、gob.Decode() で "type not registered" エラーが発生します。
func init() {
	gob.Register(MyCustomData{})
	// big.Int 自体は標準ライブラリの型なので、通常は明示的に登録する必要はありませんが、
	// 念のため登録しておくことも可能です（Goのバージョンによっては必要になるケースもごく稀にあります）。
	// gob.Register(&big.Int{})
}

func main() {
	// 1. 元の MyCustomData 構造体を作成
	originalData := MyCustomData{
		ID:        123,
		Name:      "重要な取引ID",
		BigNumber: big.NewInt(0).SetString("100000000000000000000000000000000000000000000000000000000000000000", 10),
		IsActive:  true,
	}
	fmt.Printf("元のデータ: %+v (BigNumber: %s)\n", originalData, originalData.BigNumber.String())

	// 2. エンコード先のバッファを準備
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)

	// 3. MyCustomData 構造体をエンコード
	err := enc.Encode(originalData)
	if err != nil {
		fmt.Printf("エンコードエラー: %v\n", err)
		return
	}
	fmt.Printf("エンコードされたバイト列の長さ: %dバイト\n", buf.Len())

	// 4. デコード先の MyCustomData 構造体を準備
	var decodedData MyCustomData
	dec := gob.NewDecoder(&buf)

	// 5. MyCustomData 構造体をデコード
	err = dec.Decode(&decodedData) // ポインタを渡す
	if err != nil {
		fmt.Printf("デコードエラー: %v\n", err)
		return
	}
	fmt.Printf("デコードされたデータ: %+v (BigNumber: %s)\n", decodedData, decodedData.BigNumber.String())

	// 6. 元のデータとデコードされたデータを比較して確認
	if originalData.ID == decodedData.ID &&
		originalData.Name == decodedData.Name &&
		originalData.IsActive == decodedData.IsActive &&
		originalData.BigNumber.Cmp(decodedData.BigNumber) == 0 {
		fmt.Println("成功: 元の構造体とデコードされた構造体は一致します。")
	} else {
		fmt.Println("エラー: 元の構造体とデコードされた構造体は一致しません。")
	}
}

実行結果例

元のデータ: {ID:123 Name:重要な取引ID BigNumber:100000000000000000000000000000000000000000000000000000000000000000 IsActive:true} (BigNumber: 100000000000000000000000000000000000000000000000000000000000000000)
エンコードされたバイト列の長さ: 94バイト
デコードされたデータ: {ID:123 Name:重要な取引ID BigNumber:100000000000000000000000000000000000000000000000000000000000000000 IsActive:true} (BigNumber: 100000000000000000000000000000000000000000000000000000000000000000)
成功: 元の構造体とデコードされた構造体は一致します。

big.Intポインタがnilである場合でも、gobはそれを正しくエンコードし、デコード時にnilとして復元します。

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"math/big"
)

type DataWithOptionalBigInt struct {
	ID        int
	OptionalNum *big.Int // nil の可能性がある
}

func init() {
	gob.Register(DataWithOptionalBigInt{})
}

func main() {
	// 1. OptionalNum が nil の場合のデータを作成
	originalDataNil := DataWithOptionalBigInt{
		ID:        200,
		OptionalNum: nil, // big.Int は nil
	}
	fmt.Printf("元のデータ (nilの場合): %+v (OptionalNum is nil: %t)\n", originalDataNil, originalDataNil.OptionalNum == nil)

	var bufNil bytes.Buffer
	encNil := gob.NewEncoder(&bufNil)
	err := encNil.Encode(originalDataNil)
	if err != nil {
		fmt.Printf("エンコードエラー (nil): %v\n", err)
		return
	}
	fmt.Printf("エンコードされたバイト列の長さ (nil): %dバイト\n", bufNil.Len())

	var decodedDataNil DataWithOptionalBigInt
	decNil := gob.NewDecoder(&bufNil)
	err = decNil.Decode(&decodedDataNil)
	if err != nil {
		fmt.Printf("デコードエラー (nil): %v\n", err)
		return
	}
	fmt.Printf("デコードされたデータ (nilの場合): %+v (OptionalNum is nil: %t)\n", decodedDataNil, decodedDataNil.OptionalNum == nil)

	if decodedDataNil.OptionalNum == nil {
		fmt.Println("成功: OptionalNum が nil としてデコードされました。")
	} else {
		fmt.Println("エラー: OptionalNum が nil ではありません。")
	}

	fmt.Println("---")

	// 2. OptionalNum に値がある場合のデータを作成
	originalDataWithValue := DataWithOptionalBigInt{
		ID:        201,
		OptionalNum: big.NewInt(999888777666),
	}
	fmt.Printf("元のデータ (値がある場合): %+v (OptionalNum is nil: %t)\n", originalDataWithValue, originalDataWithValue.OptionalNum == nil)

	var bufValue bytes.Buffer
	encValue := gob.NewEncoder(&bufValue)
	err = encValue.Encode(originalDataWithValue)
	if err != nil {
		fmt.Printf("エンコードエラー (値がある場合): %v\n", err)
		return
	}
	fmt.Printf("エンコードされたバイト列の長さ (値がある場合): %dバイト\n", bufValue.Len())

	var decodedDataWithValue DataWithOptionalBigInt
	decValue := gob.NewDecoder(&bufValue)
	err = decValue.Decode(&decodedDataWithValue)
	if err != nil {
		fmt.Printf("デコードエラー (値がある場合): %v\n", err)
		return
	}
	fmt.Printf("デコードされたデータ (値がある場合): %+v (OptionalNum is nil: %t, Value: %s)\n",
		decodedDataWithValue, decodedDataWithValue.OptionalNum == nil, decodedDataWithValue.OptionalNum.String())

	if decodedDataWithValue.OptionalNum != nil && originalDataWithValue.OptionalNum.Cmp(decodedDataWithValue.OptionalNum) == 0 {
		fmt.Println("成功: OptionalNum が正しくデコードされました。")
	} else {
		fmt.Println("エラー: OptionalNum のデコードに問題があります。")
	}
}

元のデータ (nilの場合): {ID:200 OptionalNum:<nil>} (OptionalNum is nil: true)
エンコードされたバイト列の長さ (nil): 20バイト
デコードされたデータ (nilの場合): {ID:200 OptionalNum:<nil>} (OptionalNum is nil: true)
成功: OptionalNum が nil としてデコードされました。
---
元のデータ (値がある場合): {ID:201 OptionalNum:999888777666} (OptionalNum is nil: false)
エンコードされたバイト列の長さ (値がある場合): 30バイト
デコードされたデータ (値がある場合): {ID:201 OptionalNum:999888777666} (OptionalNum is nil: false, Value: 999888777666)
成功: OptionalNum が正しくデコードされました。

主な代替手段は以下の通りです。

文字列変換
big.Intを文字列に変換してシリアライズし、デシリアライズ時に文字列からbig.Intに復元する。
バイト列変換
big.Intをバイト列に変換してシリアライズし、デシリアライズ時にバイト列からbig.Intに復元する。
カスタムMarshaler/Unmarshalerインターフェースの実装
json.Marshaler/json.Unmarshalerやencoding.TextMarshaler/encoding.TextUnmarshalerなどを実装する。

文字列変換 (String() と SetString())

最もシンプルで人間が読みやすい方法です。JSONやXML、プレーンテキストなど、文字列ベースのフォーマットに適しています。

長所

実装が非常に簡単。
異なる言語間での互換性が高い（文字列として渡せるため）。
人間が読みやすい。

短所

数値計算には向かない（デシリアライズ後にbig.Intに戻す必要がある）。
バイナリ形式に比べてサイズが大きくなる可能性がある。

Goでの実装例 (JSONの場合)

big.Intは直接JSONにマーシャリングできないため、通常はカスタムの型を使ってJSONに変換します。

package main

import (
	"encoding/json"
	"fmt"
	"math/big"
)

// MyDataString は big.Int を文字列として扱う構造体
type MyDataString struct {
	ID    int    `json:"id"`
	Value string `json:"value"` // big.Int を文字列として保存
}

func main() {
	// 1. big.Int を含む元のデータ
	originalInt := big.NewInt(0).SetString("123456789012345678901234567890", 10)
	originalData := MyDataString{
		ID:    1,
		Value: originalInt.String(), // big.Int を文字列に変換
	}
	fmt.Printf("元のデータ (文字列): %+v\n", originalData)

	// 2. JSONエンコード
	jsonData, err := json.MarshalIndent(originalData, "", "  ")
	if err != nil {
		fmt.Printf("JSONエンコードエラー: %v\n", err)
		return
	}
	fmt.Printf("JSONデータ:\n%s\n", string(jsonData))

	// 3. JSONデコード
	var decodedData MyDataString
	err = json.Unmarshal(jsonData, &decodedData)
	if err != nil {
		fmt.Printf("JSONデコードエラー: %v\n", err)
		return
	}
	fmt.Printf("デコードされたデータ (文字列): %+v\n", decodedData)

	// 4. 文字列から big.Int に復元
	restoredInt := new(big.Int)
	_, ok := restoredInt.SetString(decodedData.Value, 10) // 文字列から big.Int に変換
	if !ok {
		fmt.Printf("big.Int 復元エラー: %s\n", decodedData.Value)
		return
	}
	fmt.Printf("復元された big.Int: %s\n", restoredInt.String())

	// 比較
	if originalInt.Cmp(restoredInt) == 0 {
		fmt.Println("成功: big.Int は文字列を介して正しくシリアライズ/デシリアライズされました。")
	} else {
		fmt.Println("エラー: big.Int の復元に失敗しました。")
	}
}

バイト列変換 (Bytes() と SetBytes())

big.Intには、その値をバイト列に変換するBytes()メソッドと、バイト列からbig.Intを復元するSetBytes()メソッドが用意されています。これはバイナリ形式のシリアライゼーションに適しています。

長所

big.Intが提供する組み込みメソッドを使用するため、信頼性が高い。
高速なシリアライズ/デシリアライズが可能。
非常にコンパクトな表現。

短所

Go以外の言語でバイト列を扱う場合、big.Intの内部表現を理解する必要がある。
異なるシステム間でのエンディアンの問題に注意が必要な場合がある（Bytes()はビッグエンディアン）。
人間が読めない。

Goでの実装例 (直接バイト列を保存する場合)

package main

import (
	"encoding/hex" // バイト列を16進数文字列に変換して表示するため
	"fmt"
	"math/big"
)

func main() {
	// 1. big.Int を含む元のデータ
	originalInt := big.NewInt(0).SetString("123456789012345678901234567890", 10)
	fmt.Printf("元の big.Int: %s\n", originalInt.String())

	// 2. big.Int をバイト列に変換
	// Bytes() は big.Int の絶対値をビッグエンディアンのバイト列として返します。
	// 0 の場合、nil スライスを返します。
	byteRepresentation := originalInt.Bytes()
	fmt.Printf("バイト列 (hex): %s\n", hex.EncodeToString(byteRepresentation))

	// 3. バイト列から big.Int に復元
	restoredInt := new(big.Int)
	restoredInt.SetBytes(byteRepresentation) // バイト列から big.Int に変換

	fmt.Printf("復元された big.Int: %s\n", restoredInt.String())

	// 比較
	if originalInt.Cmp(restoredInt) == 0 {
		fmt.Println("成功: big.Int はバイト列を介して正しくシリアライズ/デシリアライズされました。")
	} else {
		fmt.Println("エラー: big.Int の復元に失敗しました。")
	}
}

カスタムMarshaler/Unmarshalerインターフェースの実装

json.Marshaler/json.Unmarshalerインターフェースなどを実装することで、Goの標準ライブラリ（encoding/jsonなど）がbig.Intを自動的に扱えるようにできます。これは、構造体の中に*big.Int型のフィールドがある場合に非常に便利です。

長所

外部ライブラリに依存しない。
Goの標準的なシリアライゼーション機構と統合される。
json.Marshal/json.Unmarshalなどを直接呼び出せるため、コードが簡潔になる。

短所

JSONなどのテキスト形式の場合、文字列変換が内部で行われるため、サイズは文字列変換と同じ。
インターフェースの実装が必要（少し手間がかかる）。

Goでの実装例 (JSONの場合)

package main

import (
	"encoding/json"
	"fmt"
	"strings"
	"math/big"
)

// JSONBigInt は big.Int を JSON との間でマーシャリング/アンマーシャリングするためのカスタム型です。
// *big.Int をベースにして、Marshaler と Unmarshaler インターフェースを実装します。
type JSONBigInt big.Int

// MarshalJSON は JSONBigInt を JSON にマーシャリングするためのメソッドです。
// big.Int を文字列に変換し、それをJSON文字列として返します。
func (jbi *JSONBigInt) MarshalJSON() ([]byte, error) {
	// nil の場合は "null" を返す
	if jbi == nil {
		return []byte("null"), nil
	}
	// *big.Int にキャストして String() メソッドを呼び出す
	s := (*big.Int)(jbi).String()
	// JSON文字列としてダブルクォートで囲む
	return []byte(fmt.Sprintf("%q", s)), nil
}

// UnmarshalJSON は JSONBigInt を JSON からアンマーシャリングするためのメソッドです。
// 受け取ったJSONバイト列を文字列として解釈し、それを big.Int に設定します。
func (jbi *JSONBigInt) UnmarshalJSON(data []byte) error {
	s := strings.Trim(string(data), `"`) // JSON文字列のクォートを除去

	// "null" の場合は nil を設定
	if s == "null" {
		// 受信側のポインタが nil の場合、ここで新しい big.Int を作成する必要がある
		// ただし、通常はUnmarshalのレシーバ (jbi) がすでに有効なポインタなので、
		// その値をゼロクリアしてnilと同等にするか、またはレシーバ自体をnilにする
		// ここでは SetString が "0" を返すことを利用
		(*big.Int)(jbi).SetString("0", 10) // または *jbi = JSONBigInt{} でゼロ値にする
		return nil
	}

	// big.Int にキャストして SetString() メソッドを呼び出す
	_, ok := (*big.Int)(jbi).SetString(s, 10)
	if !ok {
		return fmt.Errorf("invalid big.Int string: %s", s)
	}
	return nil
}

// MyDataWithCustomJSON はカスタムJSONBigIntを含む構造体
type MyDataWithCustomJSON struct {
	ID    int         `json:"id"`
	Value *JSONBigInt `json:"value"` // カスタム型を使用
}

func main() {
	// 1. big.Int を含む元のデータ
	originalInt := big.NewInt(0).SetString("999999999999999999999999999999", 10)
	originalData := MyDataWithCustomJSON{
		ID:    2,
		Value: (*JSONBigInt)(originalInt), // big.Int をカスタム型にキャスト
	}
	fmt.Printf("元のデータ (カスタムJSON): %+v (Value: %s)\n", originalData, originalInt.String())

	// 2. JSONエンコード
	jsonData, err := json.MarshalIndent(originalData, "", "  ")
	if err != nil {
		fmt.Printf("JSONエンコードエラー: %v\n", err)
		return
	}
	fmt.Printf("JSONデータ:\n%s\n", string(jsonData))

	// 3. JSONデコード
	var decodedData MyDataWithCustomJSON
	err = json.Unmarshal(jsonData, &decodedData)
	if err != nil {
		fmt.Printf("JSONデコードエラー: %v\n", err)
		return
	}
	fmt.Printf("デコードされたデータ (カスタムJSON): %+v (Value: %s)\n", decodedData, (*big.Int)(decodedData.Value).String())

	// 比較
	if originalInt.Cmp((*big.Int)(decodedData.Value)) == 0 {
		fmt.Println("成功: big.Int はカスタムJSONマーシャリング/アンマーシャリングを介して正しくシリアライズ/デシリアライズされました。")
	} else {
		fmt.Println("エラー: big.Int の復元に失敗しました。")
	}

	// nil の場合もテスト
	fmt.Println("\n--- nil のテスト ---")
	originalDataNil := MyDataWithCustomJSON{
		ID:    3,
		Value: nil,
	}
	fmt.Printf("元のデータ (nil): %+v\n", originalDataNil)

	jsonDataNil, err := json.MarshalIndent(originalDataNil, "", "  ")
	if err != nil {
		fmt.Printf("JSONエンコードエラー (nil): %v\n", err)
		return
	}
	fmt.Printf("JSONデータ (nil):\n%s\n", string(jsonDataNil))

	var decodedDataNil MyDataWithCustomJSON
	err = json.Unmarshal(jsonDataNil, &decodedDataNil)
	if err != nil {
		fmt.Printf("JSONデコードエラー (nil): %v\n", err)
		return
	}
	fmt.Printf("デコードされたデータ (nil): %+v\n", decodedDataNil)
	if decodedDataNil.Value == nil {
		fmt.Println("成功: nil の big.Int は正しくデコードされました。")
	} else {
		fmt.Println("エラー: nil の big.Int のデコードに失敗しました。")
	}
}

どの方法を選ぶべきか？

Goの標準的なシリアライゼーション（例: encoding/json）とシームレスに統合したい場合
カスタムMarshaler/Unmarshalerインターフェースの実装が最もGoらしい方法です。これにより、他のデータ型と同じようにbig.Intを扱えるようになります。
パフォーマンスやデータサイズが非常に重要で、Go-to-Goの通信が多い場合
gobを使用するか、big.IntのBytes()/SetBytes()メソッドを直接利用してバイナリ形式でやり取りするのが最適です。
簡単なケースや人間が読める必要性がある場合
文字列変換が最も手軽です。JSONなどの設定ファイルやAPI通信に適しています。

big.Int.GobDecode()はGobプロトコルに特化した内部メソッドであるため、上記のような代替手段は、特定のニーズ（例：JSONでの通信、ファイルへのコンパクトな保存）に合わせて柔軟に選択できる強力な選択肢となります。 Go言語のbig.Int.GobDecode()の代替となるプログラミング手法について説明します。

GobDecode()はGo言語固有のシリアライゼーション形式であるGob形式でbig.Intをデコードするためのものです。GobはGoプログラム間の通信や永続化に非常に効率的ですが、Go以外の言語との連携には適していません。

big.Intのような任意精度整数を扱う場合、異なるシステムや言語とデータを交換する必要があることがよくあります。そのような場合、Gob以外の、より汎用的なシリアライゼーション方法を検討する必要があります。

以下に主な代替手法を挙げ、それぞれの特徴とbig.Intでの利用方法を説明します。

文字列形式でのシリアライゼーション

最もシンプルで、どの言語でも確実に扱える方法です。big.Intの値を10進数（または16進数など）の文字列に変換して保存・転送し、必要に応じて文字列からbig.Intに復元します。

特徴

効率
バイナリ形式に比べると、サイズが大きくなり、エンコード/デコードのパフォーマンスは劣る可能性があります。
互換性
システムや言語間の互換性が非常に高いです。
汎用性
ほとんどのプログラミング言語で文字列から数値への変換、またはその逆の変換が可能です。
可読性
人間が読みやすく、デバッグが容易です。

big.Intでの利用方法

デコード (SetString)
big.IntのSetString(s string, base int)メソッドを使用します。
- new(big.Int).SetString("...", 10): 10進数の文字列から復元します。
- new(big.Int).SetString("...", 16): 16進数の文字列から復元します。
エンコード (String)
big.IntのString()メソッドまたはText(base)メソッドを使用します。
- myInt.String(): 10進数の文字列を返します。
- myInt.Text(16): 16進数の文字列を返します（"0x" プレフィックスなし）。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	originalInt := new(big.Int)
	originalInt.SetString("1234567890123456789012345678901234567890", 10)
	fmt.Printf("元の big.Int: %s\n", originalInt.String())

	// シリアライズ (文字列へ)
	str := originalInt.String()
	fmt.Printf("文字列形式: %s\n", str)

	// デシリアライズ (文字列から)
	decodedInt := new(big.Int)
	_, ok := decodedInt.SetString(str, 10) // 10進数としてデコード
	if !ok {
		fmt.Println("文字列からのデコードに失敗しました。")
		return
	}
	fmt.Printf("デコードされた big.Int: %s\n", decodedInt.String())

	if originalInt.Cmp(decodedInt) == 0 {
		fmt.Println("成功: 文字列変換によるシリアライズ/デシリアライズは一致します。")
	}
}

JSON (JavaScript Object Notation)

Web APIなどで広く使われる、人間が読める形式のデータ交換フォーマットです。Goのencoding/jsonパッケージを利用します。

特徴

big.Intの扱い
そのままではJSONの数値型では精度が失われる可能性があるため、文字列として扱うのが一般的です。
柔軟性
オブジェクト（マップ）や配列など、複雑なデータ構造を表現できます。
可読性
文字列形式と同様に読みやすいです。
相互運用性
多くのプログラミング言語でサポートされており、異なるシステム間のデータ交換に最適です。

big.Intでの利用方法

big.Int自体はjson.Marshalerおよびjson.Unmarshalerインターフェースを直接実装していません。そのため、デフォルトではbig.Intはポインタ値としてJSONにエンコードされます（"null"またはアドレス）。これを避けるために、カスタムのMarshalJSONとUnmarshalJSONメソッドを実装したラッパー型を使用するのが一般的です。

package main

import (
	"encoding/json"
	"fmt"
	"math/big"
)

// JSONBigInt は big.Int の JSON シリアライズ/デシリアライズを扱うためのラッパー型です。
// 通常、大きな整数は文字列としてJSONに格納するのが安全です。
type JSONBigInt big.Int

// MarshalJSON は JSONBigInt を JSON バイト列に変換します。
// big.Int の String() メソッドを使って文字列としてエンコードします。
func (j *JSONBigInt) MarshalJSON() ([]byte, error) {
	if j == nil {
		return []byte("null"), nil
	}
	// big.Int(j) で *JSONBigInt を *big.Int に変換
	return []byte(fmt.Sprintf(`"%s"`, (*big.Int)(j).String())), nil
}

// UnmarshalJSON は JSON バイト列から JSONBigInt に変換します。
// 文字列としてデコードし、それを big.Int の SetString() で復元します。
func (j *JSONBigInt) UnmarshalJSON(data []byte) error {
	if string(data) == "null" {
		// j は既に new(JSONBigInt) で初期化されている可能性があるため、nilにする
		// ただし、構造体のフィールドの場合、ポインタ自体をnilにすることはできないため、
		// 内部の big.Int を0に設定するか、適切なゼロ値を考慮する
		(*big.Int)(j).SetInt64(0) // 例として0に設定
		return nil
	}
	var s string
	if err := json.Unmarshal(data, &s); err != nil {
		return fmt.Errorf("JSONBigInt: 文字列へのアンマーシャルに失敗: %w", err)
	}
	// big.Int(j) で *JSONBigInt を *big.Int に変換
	_, ok := (*big.Int)(j).SetString(s, 10)
	if !ok {
		return fmt.Errorf("JSONBigInt: %q を big.Int に変換できませんでした", s)
	}
	return nil
}

// データ構造の例
type Data struct {
	ID    int         `json:"id"`
	Value *JSONBigInt `json:"value"` // カスタムラッパー型を使用
}

func main() {
	// 元のデータ
	originalData := Data{
		ID:    1,
		Value: (*JSONBigInt)(big.NewInt(0).SetString("99999999999999999999999999999999999999999", 10)),
	}
	fmt.Printf("元のデータ: %+v (Value: %s)\n", originalData, (*big.Int)(originalData.Value).String())

	// JSONにマーシャル
	jsonData, err := json.MarshalIndent(originalData, "", "  ") // 見やすいようにインデント付きで
	if err != nil {
		fmt.Printf("JSONマーシャルエラー: %v\n", err)
		return
	}
	fmt.Printf("マーシャルされたJSON:\n%s\n", string(jsonData))

	// JSONをアンマーシャル
	var decodedData Data
	err = json.Unmarshal(jsonData, &decodedData)
	if err != nil {
		fmt.Printf("JSONアンマーシャルエラー: %v\n", err)
		return
	}
	fmt.Printf("アンマーシャルされたデータ: %+v (Value: %s)\n", decodedData, (*big.Int)(decodedData.Value).String())

	// 比較
	if originalData.ID == decodedData.ID &&
		(*big.Int)(originalData.Value).Cmp((*big.Int)(decodedData.Value)) == 0 {
		fmt.Println("成功: JSON変換によるシリアライズ/デシリアライズは一致します。")
	} else {
		fmt.Println("エラー: JSON変換によるシリアライズ/デシリアライズが一致しません。")
	}
}

Protocol Buffers (Protobuf)

Googleが開発した、言語ニュートラルで拡張可能なシリアライゼーション形式です。スキーマ定義言語（.protoファイル）を使用し、それから各言語のコードを生成します。

特徴

big.Intの扱い
Protobufにはネイティブの任意精度整数型がないため、通常はstring型として扱うか、バイト配列（bytes）として扱う必要があります。
クロス言語
多くの言語で利用でき、マイクロサービスなどの分散システムに適しています。
スキーマベース
厳密なスキーマ定義により、データ構造の一貫性を保証し、前方・後方互換性をサポートします。
高速
エンコード/デコードが高速です。
コンパクト
バイナリ形式で、非常に小さく効率的なデータサイズを実現します。

big.Intでの利用方法

.protoファイルでstring型またはbytes型として定義します。

例 (概念)

your_data.protoファイル:

syntax = "proto3";

package mypackage;

message MyMessage {
  int32 id = 1;
  string big_number_str = 2; // big.Int を文字列として保存
  // bytes big_number_bytes = 3; // あるいはバイト列として保存 (後述の Marshal/UnmarshalText など)
}

Goコード（protocで生成されたコードを使用）：

// このコードは `protoc` コマンドで生成されます
// type MyMessage struct {
//    Id          int32
//    BigNumberStr string
// }

package main

import (
	"fmt"
	"google.golang.org/protobuf/proto" // Protobufライブラリ
	"math/big"
	mypackage "./your_data_proto" // 生成されたGoパッケージのパス
)

func main() {
	originalInt := new(big.Int)
	originalInt.SetString("123456789012345678901234567890", 10)

	// Goの big.Int を Protobuf の string に変換
	msg := &mypackage.MyMessage{
		Id:          123,
		BigNumberStr: originalInt.String(),
	}

	// Protobufメッセージをシリアライズ
	data, err := proto.Marshal(msg)
	if err != nil {
		fmt.Println("Marshal error:", err)
		return
	}
	fmt.Printf("Protobufエンコードされたバイト列の長さ: %d\n", len(data))

	// Protobufメッセージをデシリアライズ
	decodedMsg := &mypackage.MyMessage{}
	err = proto.Unmarshal(data, decodedMsg)
	if err != nil {
		fmt.Println("Unmarshal error:", err)
		return
	}

	// Protobufの string から Goの big.Int に変換
	decodedInt := new(big.Int)
	_, ok := decodedInt.SetString(decodedMsg.BigNumberStr, 10)
	if !ok {
		fmt.Println("Protobuf文字列からのデコードに失敗しました。")
		return
	}

	fmt.Printf("デコードされたID: %d, big.Int: %s\n", decodedMsg.Id, decodedInt.String())

	if originalInt.Cmp(decodedInt) == 0 {
		fmt.Println("成功: Protobuf変換によるシリアライズ/デシリアライズは一致します。")
	}
}

encoding/binary パッケージ

Goのencoding/binaryパッケージは、固定サイズまたは可変サイズの数値をバイト列に直接変換するために使用できます。big.Intは直接は対応していませんが、big.Intの内部表現（big.Int.Bytes()とbig.Int.SetBytes()）と組み合わせて使用できます。

特徴

互換性
他のシステムとの互換性を持たせるには、バイトオーダーやエンコーディングルールを厳密に定義し、共有する必要があります。
高速
直接的なバイト操作のため高速です。
非常にコンパクト
オーバーヘッドが少ない純粋なバイナリ表現です。
低レベル制御
バイトオーダー（エンディアン）などを細かく制御できます。

big.Intでの利用方法

big.Intには、符号なし整数としてバイト列に変換するBytes()メソッドと、バイト列から復元するSetBytes()メソッドがあります。これらを利用します。符号（正負）は別途保存する必要があります。

package main

import (
	"bytes"
	"encoding/binary" // Goの基本データ型をバイナリ変換
	"fmt"
	"math/big"
)

func main() {
	originalInt := new(big.Int)
	originalInt.SetString("-123456789012345678901234567890", 10) // 負の数
	fmt.Printf("元の big.Int: %s\n", originalInt.String())

	// 1. big.Int の符号を保存
	isNegative := originalInt.Sign() == -1

	// 2. big.Int を符号なしバイト列に変換
	// Abs() は絶対値を取得し、Bytes() はそのバイト表現を返します。
	absBytes := new(big.Int).Abs(originalInt).Bytes()

	var buf bytes.Buffer

	// 3. 符号をエンコード (例: 1バイトの bool または int8)
	// trueなら1, falseなら0
	var signByte byte
	if isNegative {
		signByte = 1
	} else {
		signByte = 0
	}
	buf.WriteByte(signByte)

	// 4. バイト列の長さをエンコード (可変長整数 Varint を使用すると効率的)
	// binary.PutUvarint は uint64 を可変長バイト列に変換
	lenBuf := make([]byte, binary.MaxVarintLen64)
	n := binary.PutUvarint(lenBuf, uint64(len(absBytes)))
	buf.Write(lenBuf[:n])

	// 5. 実際の数値のバイト列をエンコード
	buf.Write(absBytes)

	fmt.Printf("エンコードされたバイト列の長さ: %dバイト\n", buf.Len())

	// デシリアライズ
	readBuf := bytes.NewReader(buf.Bytes())

	// 1. 符号をデコード
	decodedSignByte, err := readBuf.ReadByte()
	if err != nil {
		fmt.Println("符号のデコードエラー:", err)
		return
	}
	decodedIsNegative := decodedSignByte == 1

	// 2. バイト列の長さをデコード
	decodedLen, err := binary.ReadUvarint(readBuf)
	if err != nil {
		fmt.Println("長さのデコードエラー:", err)
		return
	}

	// 3. 実際の数値のバイト列をデコード
	decodedAbsBytes := make([]byte, decodedLen)
	_, err = readBuf.Read(decodedAbsBytes)
	if err != nil {
		fmt.Println("数値バイト列のデコードエラー:", err)
		return
	}

	// 4. big.Int をバイト列から復元
	decodedInt := new(big.Int)
	decodedInt.SetBytes(decodedAbsBytes)

	// 5. 符号を適用
	if decodedIsNegative {
		decodedInt.Neg(decodedInt) // 負の数を適用
	}

	fmt.Printf("デコードされた big.Int: %s\n", decodedInt.String())

	if originalInt.Cmp(decodedInt) == 0 {
		fmt.Println("成功: バイナリ変換によるシリアライズ/デシリアライズは一致します。")
	} else {
		fmt.Println("エラー: バイナリ変換によるシリアライズ/デシリアライズが一致しません。")
	}
}

MessagePack

JSONよりもコンパクトなバイナリシリアライゼーション形式です。軽量で高速なのが特徴で、組み込みシステムや帯域幅が限られた環境での利用に適しています。github.com/vmihailenco/msgpack/v5などのサードパーティライブラリを使用します。

特徴

big.Intの扱い
ライブラリによってはbig.Intを直接サポートしているものもありますが、基本的には文字列やバイト列として扱うことになります。
クロス言語
多くの言語でライブラリが提供されています。
スキーマレス
JSONと同様にスキーマ定義が不要なため、柔軟です。
高速
JSONよりもエンコード/デコードが高速です。
コンパクト
JSONよりもデータサイズが小さいです。

package main

import (
	"fmt"
	"math/big"

	"github.com/vmihailenco/msgpack/v5" // MessagePackライブラリをインポート
)

// MyMessagePackData は big.Int を含むカスタム構造体です。
type MyMessagePackData struct {
	ID        int      `msgpack:"id"`
	BigNumber string   `msgpack:"big_number"` // big.Int を文字列として保存
}

func main() {
	originalInt := new(big.Int)
	originalInt.SetString("1122334455667788990011223344556677889900", 10)

	originalData := MyMessagePackData{
		ID:        456,
		BigNumber: originalInt.String(), // big.Int を文字列に変換して格納
	}
	fmt.Printf("元のデータ: %+v (BigNumber: %s)\n", originalData, originalInt.String())

	// MessagePackにエンコード
	encoded, err := msgpack.Marshal(&originalData)
	if err != nil {
		fmt.Printf("MessagePackエンコードエラー: %v\n", err)
		return
	}
	fmt.Printf("MessagePackエンコードされたバイト列の長さ: %dバイト\n", len(encoded))

	// MessagePackをデコード
	var decodedData MyMessagePackData
	err = msgpack.Unmarshal(encoded, &decodedData)
	if err != nil {
		fmt.Printf("MessagePackデコードエラー: %v\n", err)
		return
	}

	// デコードされた文字列を big.Int に変換
	decodedInt := new(big.Int)
	_, ok := decodedInt.SetString(decodedData.BigNumber, 10)
	if !ok {
		fmt.Println("MessagePack文字列からのデコードに失敗しました。")
		return
	}

	fmt.Printf("デコードされたデータ: %+v (BigNumber: %s)\n", decodedData, decodedInt.String())

	if originalInt.Cmp(decodedInt) == 0 {
		fmt.Println("成功: MessagePack変換によるシリアライズ/デシリアライズは一致します。")
	} else {
		fmt.Println("エラー: MessagePack変換によるシリアライズ/デシリアライズが一致しません。")
	}
}

JSONよりもコンパクトで高速なスキーマレスバイナリ形式が必要な場合
MessagePack (サードパーティライブラリ、big.Intは文字列またはバイト列として扱う)
低レベルなバイナリ操作が必要で、他のシステムとの厳密なバイト表現を共有する場合
encoding/binary (big.Int.Bytes()/SetBytes()と組み合わせて符号も別途扱う)
最もシンプルで言語非依存のデータ交換
文字列形式 (シンプルだが、データ構造が複雑になると管理が大変)
非常にコンパクトで高速なバイナリ形式が必要で、厳密なスキーマ定義も許容できる場合
Protocol Buffers (big.Intはstringまたはbytesとして定義)
人間が読める形式で、かつクロス言語でのデータ交換が必要な場合
JSON (文字列としてbig.Intを扱うカスタムマーシャラー/アンマーシャラーが必須)
Goプログラム間での高速なデータ交換/永続化
encoding/gob (最も効率的でGoの型システムに最適)

Go言語 big.Int と GobDecode：実践的なコード例で学ぶデータ永続化

使用目的

どのように機能するか

gob: type not registered for decoding (型が登録されていないエラー)

gob: decoding zero-length big.Int (ゼロ長のbig.Intをデコードしようとしている)

データ形式の不一致 (GobDecodeが不正なバイト列を受け取る)

big.Intのポインタと値の扱い

例1: 単一の big.Int のエンコードとデコード

例2: big.Int を含むカスタム構造体のエンコードとデコード

文字列変換 (String() と SetString())

バイト列変換 (Bytes() と SetBytes())

カスタムMarshaler/Unmarshalerインターフェースの実装

どの方法を選ぶべきか？

文字列形式でのシリアライゼーション

JSON (JavaScript Object Notation)

Protocol Buffers (Protobuf)

encoding/binary パッケージ

MessagePack

例1: 単一の `big.Int` のエンコードとデコード

例2: `big.Int` を含むカスタム構造体のエンコードとデコード