MENU
  1. ホーム
  2. Go
  3. Goでカスタム型をJSONフィールドとしてエンコード・デコードする方法を徹底解説

Goでカスタム型をJSONフィールドとしてエンコード・デコードする方法を徹底解説

Go

Go言語を利用する際、データのやり取りにおいてJSONは欠かせないフォーマットの一つです。標準ライブラリのencoding/jsonパッケージは便利なツールを提供していますが、カスタム型を扱う場面では少し工夫が必要です。本記事では、Goでカスタム型をJSONフィールドとしてエンコード・デコードする方法を解説します。基本的な操作から、MarshalJSONやUnmarshalJSONの実装、具体例や応用例までを丁寧に取り上げ、現実的なプログラミングの課題解決に役立つ内容をお届けします。

目次
  1. JSONとGoのデフォルト動作
    1. JSONエンコードの基本
    2. JSONデコードの基本
    3. デフォルト動作の特徴
  2. カスタム型の必要性
    1. 利用シーン
    2. 具体例
    3. カスタム型の利点
  3. Goでカスタム型を定義する方法
    1. カスタム型の基本定義
    2. 構造体を使ったカスタム型
    3. カスタム型にメソッドを追加
    4. カスタム型の用途
  4. カスタム型をJSONにエンコードする手順
    1. デフォルトのエンコード動作
    2. カスタムエンコードの実装: `MarshalJSON`の利用
    3. 構造体のエンコードとJSONタグ
    4. 注意点
  5. JSONをカスタム型にデコードする手順
    1. デフォルトのデコード動作
    2. カスタムデコードの実装: `UnmarshalJSON`の利用
    3. 構造体へのデコード
    4. 注意点
  6. `MarshalJSON`と`UnmarshalJSON`の活用
    1. `MarshalJSON`の使い方
    2. `UnmarshalJSON`の使い方
    3. `MarshalJSON`と`UnmarshalJSON`を組み合わせた例
    4. 活用のポイント
  7. カスタム型のエンコード・デコードにおける注意点
    1. 1. フォーマットの整合性
    2. 2. 必要なフィールドの欠損
    3. 3. 型の競合と拡張性
    4. 4. パフォーマンスの問題
    5. 5. エラーハンドリングの徹底
    6. 6. 未使用フィールドの対応
    7. まとめ
  8. 応用例: カスタム日付型のJSON処理
    1. 課題: 標準の日付型の制約
    2. 解決策: カスタム日付型の実装
    3. 応用例: 日付フィールドを持つ構造体
    4. 複雑なフォーマットへの対応
    5. 応用範囲
    6. まとめ
  9. 演習問題: カスタム型の実装
    1. 課題1: カスタム型`CustomCurrency`を実装
    2. 課題2: カスタム型`CustomBool`の作成
    3. 課題3: フィールドを持つカスタム構造体を活用
    4. 挑戦してみましょう！
  10. まとめ

JSONとGoのデフォルト動作


Goの標準ライブラリencoding/jsonは、JSONデータをエンコード（構造体からJSON文字列へ変換）およびデコード（JSON文字列から構造体へ変換）するための強力なツールを提供します。

JSONエンコードの基本


構造体やマップなどのデータ型をjson.Marshal関数を用いてJSON文字列に変換できます。デフォルトでは、構造体の公開フィールド（大文字で始まるもの）がJSONオブジェクトのフィールドとしてエンコードされます。

type User struct {
    Name  string
    Age   int
    Email string
}

func main() {
    user := User{Name: "Alice", Age: 30, Email: "alice@example.com"}
    jsonData, _ := json.Marshal(user)
    fmt.Println(string(jsonData))
}
// 出力: {"Name":"Alice","Age":30,"Email":"alice@example.com"}

JSONデコードの基本


json.Unmarshalを使用すると、JSON文字列を構造体やマップに変換できます。JSONのキーと構造体フィールド名が一致している必要がありますが、一部のカスタマイズも可能です。

func main() {
    jsonData := `{"Name":"Bob","Age":25,"Email":"bob@example.com"}`
    var user User
    _ = json.Unmarshal([]byte(jsonData), &user)
    fmt.Printf("%+v\n", user)
}
// 出力: {Name:Bob Age:25 Email:bob@example.com}

デフォルト動作の特徴

  • フィールド名の大文字小文字は区別されます。
  • 未公開フィールド（小文字で始まる）はエンコード・デコードの対象外です。
  • JSONタグ（例: json:"custom_name"）を使用することで、フィールド名をカスタマイズできます。

Goのデフォルト動作は便利ですが、カスタム型を利用した特殊なデータ変換には追加の実装が必要になります。次に、カスタム型の必要性について掘り下げます。

カスタム型の必要性

プログラムを設計する際、標準的なデータ型では表現しきれない独自の要件を満たすために、カスタム型を使用することがあります。これには、特定のフォーマットや振る舞いを持つデータを扱う場合が含まれます。JSONのエンコード・デコードの文脈では、カスタム型を用いることで、柔軟かつ直感的なデータ操作が可能になります。

利用シーン

  1. データフォーマットの統一
    例えば、日付や時刻を扱う場合、標準のtime.Time型ではなく、独自のフォーマット（例: YYYY-MM-DD）で処理したい場合があります。
  2. データのバリデーション
    JSONのエンコードやデコード時に、特定の条件を満たすデータだけを許容するロジックを埋め込むことができます。
  3. 可読性とメンテナンス性の向上
    カスタム型を導入することで、データ構造が明確になり、コード全体の可読性とメンテナンス性が向上します。

具体例

  • カスタム日付型
    デフォルトのtime.Timeではなく、文字列型の日付（例: "2024-01-01"）を使用したい場合。
  • 特定の数値範囲の制約
    例えば、商品の価格が負の値を持たないようにするカスタム型。
type NonNegativeInt int

func (n *NonNegativeInt) UnmarshalJSON(data []byte) error {
    var temp int
    if err := json.Unmarshal(data, &temp); err != nil {
        return err
    }
    if temp < 0 {
        return fmt.Errorf("value must be non-negative")
    }
    *n = NonNegativeInt(temp)
    return nil
}

カスタム型の利点

  • 特殊なデータ要件を満たすための柔軟性を提供。
  • データ整合性を高め、エラーを防止。
  • 再利用可能なコード構造を提供。

次に、Goでカスタム型を定義する具体的な方法について説明します。

Goでカスタム型を定義する方法

カスタム型は、Go言語でデータ構造や振る舞いをカスタマイズするために非常に役立つ機能です。カスタム型を定義することで、既存の基本型や構造体を拡張して特定の目的に適した新しい型を作成できます。

カスタム型の基本定義


Goでは、既存の型を基にしてカスタム型を定義するのが一般的です。以下はその基本例です。

type MyString string
type MyInt int

これにより、MyStringやMyIntを独自型として使用できます。これらは元の型（stringやint）と同様に動作しますが、型の明確化や専用メソッドの追加が可能です。

構造体を使ったカスタム型


構造体を定義することで、複数のフィールドを持つ複雑なデータ型を作成できます。

type User struct {
    Name  string
    Age   int
    Email string
}

この構造体を使えば、関連するデータを一つのオブジェクトとして扱うことができます。

func main() {
    user := User{Name: "Alice", Age: 30, Email: "alice@example.com"}
    fmt.Println(user)
}

カスタム型にメソッドを追加


カスタム型にメソッドを定義することで、特定のロジックをその型に関連付けることができます。

type MyInt int

func (m MyInt) Double() MyInt {
    return m * 2
}

func main() {
    num := MyInt(10)
    fmt.Println(num.Double()) // 出力: 20
}

カスタム型の用途

  • 制約付き型: 特定の範囲や条件を満たすデータ型（例: 非負の整数）。
  • 新しい振る舞いを持つ型: 基本型に特定の処理を追加したもの（例: 特定のフォーマットを持つ文字列）。
  • 構造体を用いたデータモデル: ユーザー情報やAPIレスポンスなど、複数のフィールドを持つデータモデル。

次は、これらのカスタム型をJSONにエンコードする方法について詳しく解説します。

カスタム型をJSONにエンコードする手順

Goのencoding/jsonパッケージを使用すれば、標準のデータ型だけでなくカスタム型もJSON形式にエンコードできます。カスタム型を適切にエンコードすることで、特定のフォーマットやデータ構造を反映したJSONを生成可能です。

デフォルトのエンコード動作


カスタム型は、特に追加の処理をしなくても基本型と同様にエンコードされます。ただし、カスタム型に専用のフィールドやロジックがある場合、デフォルトの挙動を変更する必要があります。

以下は、カスタム型がその基になる型と同じようにエンコードされる例です。

type MyString string

func main() {
    data := MyString("Hello, JSON!")
    jsonData, _ := json.Marshal(data)
    fmt.Println(string(jsonData))
}
// 出力: "Hello, JSON!"

カスタムエンコードの実装: `MarshalJSON`の利用


独自のエンコードロジックを実装するには、json.Marshalerインターフェースを満たすMarshalJSONメソッドをカスタム型に追加します。

type CustomDate struct {
    Year  int
    Month int
    Day   int
}

func (cd CustomDate) MarshalJSON() ([]byte, error) {
    formattedDate := fmt.Sprintf("\"%04d-%02d-%02d\"", cd.Year, cd.Month, cd.Day)
    return []byte(formattedDate), nil
}

func main() {
    date := CustomDate{Year: 2024, Month: 11, Day: 18}
    jsonData, _ := json.Marshal(date)
    fmt.Println(string(jsonData))
}
// 出力: "2024-11-18"

構造体のエンコードとJSONタグ


構造体のフィールド名はそのままJSONのキー名として使用されますが、JSONタグを使うことでキー名をカスタマイズ可能です。

type User struct {
    Name  string `json:"username"`
    Age   int    `json:"age"`
    Email string `json:"email_address,omitempty"`
}

func main() {
    user := User{Name: "Alice", Age: 30}
    jsonData, _ := json.Marshal(user)
    fmt.Println(string(jsonData))
}
// 出力: {"username":"Alice","age":30}

注意点

  • MarshalJSONの実装では、JSON文字列の形式（例: ダブルクォートで囲む）を正確に守る必要があります。
  • 構造体の未公開フィールドはエンコード対象外となります。

次に、JSONデータをカスタム型にデコードする手順について説明します。

JSONをカスタム型にデコードする手順

JSONデータをGoのカスタム型に変換するには、encoding/jsonパッケージのjson.Unmarshalを利用します。デコード処理をカスタマイズすることで、JSONデータを独自の形式で効率的に扱うことが可能です。

デフォルトのデコード動作


カスタム型は、元となる型と同じようにデコードされます。例えば、以下のコードではMyString型がstring型として処理されます。

type MyString string

func main() {
    jsonData := `"Hello, Go!"`
    var data MyString
    _ = json.Unmarshal([]byte(jsonData), &data)
    fmt.Println(data)
}
// 出力: Hello, Go!

カスタムデコードの実装: `UnmarshalJSON`の利用


カスタム型に独自のデコードロジックを追加するには、json.Unmarshalerインターフェースを満たすUnmarshalJSONメソッドを実装します。

以下は、日付文字列を独自の構造体CustomDateにデコードする例です。

type CustomDate struct {
    Year  int
    Month int
    Day   int
}

func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    _, err := fmt.Sscanf(dateStr, "%d-%d-%d", &cd.Year, &cd.Month, &cd.Day)
    return err
}

func main() {
    jsonData := `"2024-11-18"`
    var date CustomDate
    _ = json.Unmarshal([]byte(jsonData), &date)
    fmt.Printf("%+v\n", date)
}
// 出力: {Year:2024 Month:11 Day:18}

構造体へのデコード


構造体にデコードする場合、JSONのキーと構造体のフィールド名が一致している必要があります。JSONタグを使うことで、異なるキー名にも対応できます。

type User struct {
    Name  string `json:"username"`
    Age   int    `json:"age"`
    Email string `json:"email_address"`
}

func main() {
    jsonData := `{"username":"Alice","age":30,"email_address":"alice@example.com"}`
    var user User
    _ = json.Unmarshal([]byte(jsonData), &user)
    fmt.Printf("%+v\n", user)
}
// 出力: {Name:Alice Age:30 Email:alice@example.com}

注意点

  • JSONデータとGoの型構造が一致しない場合はエラーが発生します。
  • 未使用のJSONフィールドは無視されますが、正確なデコードのためには必要なフィールドを揃えるべきです。
  • カスタムデコード処理では、元のJSON形式を正確に解析するロジックを実装する必要があります。

次に、エンコード・デコードをより高度にカスタマイズするためにMarshalJSONとUnmarshalJSONを組み合わせて活用する方法を説明します。

`MarshalJSON`と`UnmarshalJSON`の活用

Goのjson.Marshalerとjson.Unmarshalerインターフェースを利用すると、JSONデータのエンコードとデコードの振る舞いを細かく制御できます。これにより、特定のフォーマットや条件を持つカスタム型を効率的に操作できます。

`MarshalJSON`の使い方


MarshalJSONは、カスタム型をJSON形式にエンコードする際の動作を定義するメソッドです。このメソッドを実装することで、JSONの出力をカスタマイズできます。

例: 日付型のエンコード

type CustomDate struct {
    Year  int
    Month int
    Day   int
}

func (cd CustomDate) MarshalJSON() ([]byte, error) {
    formattedDate := fmt.Sprintf("\"%04d-%02d-%02d\"", cd.Year, cd.Month, cd.Day)
    return []byte(formattedDate), nil
}

func main() {
    date := CustomDate{Year: 2024, Month: 11, Day: 18}
    jsonData, _ := json.Marshal(date)
    fmt.Println(string(jsonData))
}
// 出力: "2024-11-18"

`UnmarshalJSON`の使い方


UnmarshalJSONは、JSONデータをカスタム型にデコードする際の動作を定義するメソッドです。このメソッドを使うことで、特定のフォーマットを解析してカスタム型に変換できます。

例: 日付型のデコード

func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    _, err := fmt.Sscanf(dateStr, "%d-%d-%d", &cd.Year, &cd.Month, &cd.Day)
    return err
}

func main() {
    jsonData := `"2024-11-18"`
    var date CustomDate
    _ = json.Unmarshal([]byte(jsonData), &date)
    fmt.Printf("%+v\n", date)
}
// 出力: {Year:2024 Month:11 Day:18}

`MarshalJSON`と`UnmarshalJSON`を組み合わせた例


これらのメソッドを組み合わせることで、エンコードとデコードの双方向で特定のフォーマットを実現できます。

例: 日付型のエンコード・デコード

type CustomDate struct {
    Year  int
    Month int
    Day   int
}

func (cd CustomDate) MarshalJSON() ([]byte, error) {
    formattedDate := fmt.Sprintf("\"%04d-%02d-%02d\"", cd.Year, cd.Month, cd.Day)
    return []byte(formattedDate), nil
}

func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    _, err := fmt.Sscanf(dateStr, "%d-%d-%d", &cd.Year, &cd.Month, &cd.Day)
    return err
}

func main() {
    jsonData := `"2024-11-18"`
    var date CustomDate
    _ = json.Unmarshal([]byte(jsonData), &date)
    fmt.Printf("Decoded: %+v\n", date)

    encodedData, _ := json.Marshal(date)
    fmt.Printf("Encoded: %s\n", string(encodedData))
}
// 出力:
// Decoded: {Year:2024 Month:11 Day:18}
// Encoded: "2024-11-18"

活用のポイント

  1. データ形式の統一
    エンコードとデコードで一貫した形式を保つことで、データの整合性を確保できます。
  2. エラーハンドリング
    フォーマットに合わないデータが入力された場合、適切なエラーを返す実装を行います。
  3. 汎用性の向上
    カスタム型にこれらのメソッドを実装することで、他のパッケージやモジュールで再利用しやすくなります。

次は、カスタム型をエンコード・デコードする際に注意すべきポイントについて解説します。

カスタム型のエンコード・デコードにおける注意点

カスタム型をJSONのエンコード・デコードに利用する場合、特殊なデータ要件やフォーマットに対応できる反面、いくつかの注意点も存在します。これらのポイントを理解しておくことで、バグを未然に防ぎ、堅牢なコードを構築できます。

1. フォーマットの整合性


カスタム型でエンコード・デコードを行う際、JSONデータのフォーマットを正しく理解し、実装に反映する必要があります。エンコードとデコードのロジックが一致しないと、データが正しく往復しません。

例: フォーマットの整合性エラー

type CustomDate struct {
    Year  int
    Month int
    Day   int
}

func (cd CustomDate) MarshalJSON() ([]byte, error) {
    return []byte(fmt.Sprintf("\"%04d/%02d/%02d\"", cd.Year, cd.Month, cd.Day)), nil
}

func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    _, err := fmt.Sscanf(dateStr, "%04d-%02d-%02d", &cd.Year, &cd.Month, &cd.Day) // 誤ったフォーマットを使用
    return err
}

この場合、エンコードではYYYY/MM/DD形式を生成しますが、デコードではYYYY-MM-DD形式を期待しているため、エラーになります。

2. 必要なフィールドの欠損


JSONデータにカスタム型で必要なフィールドが含まれていない場合、予期せぬエラーや不完全なデータが生成される可能性があります。これを防ぐには、入力データを検証するロジックを含めるべきです。

例: フィールドの検証

func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    if len(dateStr) == 0 { // 空のデータをチェック
        return fmt.Errorf("date string cannot be empty")
    }
    _, err := fmt.Sscanf(dateStr, "%d-%d-%d", &cd.Year, &cd.Month, &cd.Day)
    return err
}

3. 型の競合と拡張性


カスタム型のエンコード・デコードは、プロジェクトが拡大すると型の競合や非互換性を引き起こす可能性があります。たとえば、同じカスタム型に複数のJSONフォーマットが必要な場合、それぞれのケースに対応するための追加の実装が複雑化します。

解決策: 一貫したルールを設定

  • JSONフォーマットのガイドラインをプロジェクト全体で統一する。
  • 型ごとに独自のエンコード・デコードを明確に分離する。

4. パフォーマンスの問題


大規模なデータセットに対してカスタムロジックを実装すると、処理速度が低下することがあります。特に、MarshalJSONやUnmarshalJSONで過剰な文字列操作を行う場合、パフォーマンスに悪影響を及ぼします。

最適化のポイント

  • エンコード・デコードのロジックを簡潔に保つ。
  • 必要ならば事前計算やキャッシュを利用する。

5. エラーハンドリングの徹底


カスタム型でのエンコード・デコード中にエラーが発生した場合、適切なメッセージを返して問題を明示する必要があります。エラーを無視すると、予期せぬ動作につながる可能性があります。

推奨エラーハンドリング例

func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return fmt.Errorf("failed to unmarshal date: %w", err)
    }
    _, err := fmt.Sscanf(dateStr, "%d-%d-%d", &cd.Year, &cd.Month, &cd.Day)
    if err != nil {
        return fmt.Errorf("invalid date format: %w", err)
    }
    return nil
}

6. 未使用フィールドの対応


JSONデータにカスタム型で使用しないフィールドが含まれている場合、それを無視する処理を明示的に行うと柔軟性が向上します。

解決策: 構造体タグの利用

type User struct {
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
    Age   int    `json:"-"`
}

omitemptyで省略可能なフィールドを指定し、"-"で無視するフィールドを定義します。

まとめ


カスタム型をエンコード・デコードに使用する際は、データフォーマットの整合性、必要なフィールドの検証、エラーハンドリング、パフォーマンスへの配慮を行うことで、信頼性の高い実装が可能になります。次は、カスタム型を活用した具体的な応用例について紹介します。

応用例: カスタム日付型のJSON処理

カスタム型を用いたJSONエンコード・デコードは、特定のフォーマットやビジネス要件に対応するための強力なツールです。ここでは、日付データを独自のフォーマットで処理する例を通して、カスタム型の応用方法を説明します。

課題: 標準の日付型の制約


Goの標準ライブラリではtime.Time型が一般的に使用されますが、以下のような要件には対応しにくい場合があります。

  • 特定のフォーマット（例: YYYY-MM-DD）。
  • 不完全な日付（例: 年と月だけ）。
  • 日付が文字列形式で表現されるAPIとの統合。

解決策: カスタム日付型の実装


以下の例では、YYYY-MM-DD形式で表現される日付をカスタム型CustomDateで処理します。

type CustomDate struct {
    Year  int
    Month int
    Day   int
}

// JSONエンコード用の`MarshalJSON`メソッドを実装
func (cd CustomDate) MarshalJSON() ([]byte, error) {
    formattedDate := fmt.Sprintf("\"%04d-%02d-%02d\"", cd.Year, cd.Month, cd.Day)
    return []byte(formattedDate), nil
}

// JSONデコード用の`UnmarshalJSON`メソッドを実装
func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    _, err := fmt.Sscanf(dateStr, "%04d-%02d-%02d", &cd.Year, &cd.Month, &cd.Day)
    return err
}

応用例: 日付フィールドを持つ構造体


CustomDate型を使用して、ユーザーの登録情報を表現する構造体を定義します。

type User struct {
    Name      string     `json:"name"`
    Email     string     `json:"email"`
    BirthDate CustomDate `json:"birth_date"`
}

func main() {
    // JSONデータのデコード
    jsonData := `{"name":"Alice","email":"alice@example.com","birth_date":"1990-05-15"}`
    var user User
    if err := json.Unmarshal([]byte(jsonData), &user); err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }
    fmt.Printf("Decoded User: %+v\n", user)

    // JSONデータのエンコード
    encodedData, err := json.Marshal(user)
    if err != nil {
        fmt.Println("Error encoding JSON:", err)
        return
    }
    fmt.Printf("Encoded JSON: %s\n", string(encodedData))
}

実行結果

Decoded User: {Name:Alice Email:alice@example.com BirthDate:{Year:1990 Month:5 Day:15}}
Encoded JSON: {"name":"Alice","email":"alice@example.com","birth_date":"1990-05-15"}

複雑なフォーマットへの対応


場合によっては、より複雑な日付形式や可変フォーマットを扱う必要があります。その場合、以下のようにtime.Parseやtime.Formatを組み合わせることが可能です。

func (cd *CustomDate) UnmarshalJSON(data []byte) error {
    var dateStr string
    if err := json.Unmarshal(data, &dateStr); err != nil {
        return err
    }
    t, err := time.Parse("2006-01-02", dateStr) // Goではこの形式がデフォルトのフォーマット
    if err != nil {
        return err
    }
    cd.Year, cd.Month, cd.Day = t.Year(), int(t.Month()), t.Day()
    return nil
}

応用範囲

  • 特定のビジネス要件: 独自フォーマットでのデータ管理。
  • API統合: 異なる日付フォーマットを扱う外部サービスとの連携。
  • データ検証: デコード時に日付の妥当性を検証。

まとめ


この例では、カスタム型を用いてJSONデータのエンコードとデコードを柔軟に処理する方法を示しました。特に日付データにおけるカスタマイズは、業務アプリケーションやAPI開発で頻繁に必要となるスキルです。次は、この内容をより深く理解するための演習問題を提示します。

演習問題: カスタム型の実装

以下の演習を通じて、カスタム型を用いたJSONエンコード・デコードの実装を実際に試してみましょう。これにより、カスタム型の利用方法と応用技術を深く理解できます。

課題1: カスタム型`CustomCurrency`を実装


次の要件を満たすカスタム型CustomCurrencyを作成してください。

  • 通貨を表す文字列をJSONとしてエンコードする際に、"$100.00"の形式にする。
  • JSONをデコードする際は、"$100.00"形式を数値型float64に変換して保持する。

テンプレートコード

type CustomCurrency float64

// MarshalJSONを実装してください

// UnmarshalJSONを実装してください

func main() {
    jsonData := `"$150.25"`
    var amount CustomCurrency
    if err := json.Unmarshal([]byte(jsonData), &amount); err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }
    fmt.Printf("Decoded amount: %.2f\n", amount)

    encodedData, err := json.Marshal(amount)
    if err != nil {
        fmt.Println("Error encoding JSON:", err)
        return
    }
    fmt.Printf("Encoded JSON: %s\n", string(encodedData))
}

課題2: カスタム型`CustomBool`の作成


CustomBool型を作成し、次の条件を満たしてください。

  • JSONの値が"yes"または"no"の場合、それをbool型に変換する。
  • "yes"はtrue、"no"はfalseにする。
  • JSONとしてエンコードする際、trueの場合は"yes"、falseの場合は"no"とする。

テンプレートコード

type CustomBool bool

// MarshalJSONを実装してください

// UnmarshalJSONを実装してください

func main() {
    jsonData := `"yes"`
    var value CustomBool
    if err := json.Unmarshal([]byte(jsonData), &value); err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }
    fmt.Printf("Decoded value: %t\n", value)

    encodedData, err := json.Marshal(value)
    if err != nil {
        fmt.Println("Error encoding JSON:", err)
        return
    }
    fmt.Printf("Encoded JSON: %s\n", string(encodedData))
}

課題3: フィールドを持つカスタム構造体を活用


次の条件を満たす構造体を作成し、JSONエンコード・デコードを試してください。

  • フィールドNameは通常の文字列として処理する。
  • フィールドBalanceは、CustomCurrency型を用いる。
  • フィールドIsActiveは、CustomBool型を用いる。

テンプレートコード

type UserAccount struct {
    Name     string       `json:"name"`
    Balance  CustomCurrency `json:"balance"`
    IsActive CustomBool   `json:"is_active"`
}

func main() {
    jsonData := `{"name":"Alice","balance":"$250.50","is_active":"yes"}`
    var account UserAccount
    if err := json.Unmarshal([]byte(jsonData), &account); err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }
    fmt.Printf("Decoded Account: %+v\n", account)

    encodedData, err := json.Marshal(account)
    if err != nil {
        fmt.Println("Error encoding JSON:", err)
        return
    }
    fmt.Printf("Encoded JSON: %s\n", string(encodedData))
}

挑戦してみましょう！


これらの演習問題を通じて、Goでのカスタム型の実装スキルを磨き、実際のプロジェクトに応用できる知識を身に付けましょう。正解例を確認したい場合は、解答をリクエストしてください！

まとめ

本記事では、Goでカスタム型をJSONフィールドとしてエンコード・デコードする方法について解説しました。基本的な標準ライブラリの動作から、MarshalJSONやUnmarshalJSONを活用したカスタムエンコード・デコードの実装まで幅広く取り上げました。

  • カスタム型は特定のフォーマットやビジネス要件に対応する柔軟性を提供します。
  • MarshalJSONとUnmarshalJSONを組み合わせることで、エンコード・デコードの挙動を細かく制御できます。
  • フォーマットの整合性やエラーハンドリングなど、実装時の注意点を理解することで堅牢なコードが書けます。
  • 応用例や演習問題を通じて、実践的なスキルを身に付けることができます。

カスタム型を使いこなすことで、GoのJSON処理の幅を広げ、効率的で拡張性の高いアプリケーションを開発できるようになるでしょう。次回のプロジェクトでぜひ活用してみてください！

Go
プログラミング JSON カスタム型 Go

コメント

コメントする

目次
  1. JSONとGoのデフォルト動作
    1. JSONエンコードの基本
    2. JSONデコードの基本
    3. デフォルト動作の特徴
  2. カスタム型の必要性
    1. 利用シーン
    2. 具体例
    3. カスタム型の利点
  3. Goでカスタム型を定義する方法
    1. カスタム型の基本定義
    2. 構造体を使ったカスタム型
    3. カスタム型にメソッドを追加
    4. カスタム型の用途
  4. カスタム型をJSONにエンコードする手順
    1. デフォルトのエンコード動作
    2. カスタムエンコードの実装: `MarshalJSON`の利用
    3. 構造体のエンコードとJSONタグ
    4. 注意点
  5. JSONをカスタム型にデコードする手順
    1. デフォルトのデコード動作
    2. カスタムデコードの実装: `UnmarshalJSON`の利用
    3. 構造体へのデコード
    4. 注意点
  6. `MarshalJSON`と`UnmarshalJSON`の活用
    1. `MarshalJSON`の使い方
    2. `UnmarshalJSON`の使い方
    3. `MarshalJSON`と`UnmarshalJSON`を組み合わせた例
    4. 活用のポイント
  7. カスタム型のエンコード・デコードにおける注意点
    1. 1. フォーマットの整合性
    2. 2. 必要なフィールドの欠損
    3. 3. 型の競合と拡張性
    4. 4. パフォーマンスの問題
    5. 5. エラーハンドリングの徹底
    6. 6. 未使用フィールドの対応
    7. まとめ
  8. 応用例: カスタム日付型のJSON処理
    1. 課題: 標準の日付型の制約
    2. 解決策: カスタム日付型の実装
    3. 応用例: 日付フィールドを持つ構造体
    4. 複雑なフォーマットへの対応
    5. 応用範囲
    6. まとめ
  9. 演習問題: カスタム型の実装
    1. 課題1: カスタム型`CustomCurrency`を実装
    2. 課題2: カスタム型`CustomBool`の作成
    3. 課題3: フィールドを持つカスタム構造体を活用
    4. 挑戦してみましょう！
  10. まとめ