MENU
  1. ホーム
  2. Go
  3. GoでJSONをGo構造体やマップに変換する方法：json.Unmarshalを徹底解説

GoでJSONをGo構造体やマップに変換する方法：json.Unmarshalを徹底解説

Go

JSONを扱う際、Goプログラミング言語はその効率性とシンプルな設計で広く利用されています。その中でも、JSONデータをGoで処理可能な形式に変換する機能は、API開発やデータ処理において欠かせません。本記事では、Go標準ライブラリが提供するjson.Unmarshalを用いて、JSON文字列をGoの構造体やマップに変換する方法を詳しく解説します。基本的な構文から応用例までを網羅し、初心者でも理解しやすい内容を目指します。これにより、JSONを効率的に操作し、実際のプロジェクトで活用できるスキルを習得できるでしょう。

目次
  1. JSONとGoの基本概念
    1. JSONの基本構造
    2. GoとJSONの相性
  2. `json.Unmarshal`の基本構文と動作原理
    1. 基本構文
    2. 使用例
    3. 動作原理
    4. エラーの扱い
  3. JSONをGo構造体に変換する手順
    1. 1. 構造体の定義
    2. 2. JSON文字列の用意
    3. 3. `json.Unmarshal`を使用してデコード
    4. 4. 結果
    5. 5. 応用例：オプションフィールドの処理
  4. JSONをGoマップに変換する手順
    1. 1. Goマップの基本構造
    2. 2. JSONデータの準備
    3. 3. `json.Unmarshal`を使った変換
    4. 4. 結果
    5. 5. 値の型変換
    6. 6. 動的な構造を持つJSONの処理
    7. 7. マップと構造体の使い分け
  5. ネストされたJSONの取り扱い
    1. 1. JSONデータの例
    2. 2. 構造体を使った処理
    3. 3. マップを使った処理
    4. 4. 構造体とマップの選択基準
  6. エラーハンドリングとデバッグのポイント
    1. 1. エラーの基本的な検出方法
    2. 2. JSON構文エラーの対処
    3. 3. 型の不一致エラーの対処
    4. 4. 欠損フィールドの処理
    5. 5. デバッグのポイント
    6. 6. Go Playgroundを活用
  7. 応用例：APIレスポンスの解析
    1. 1. サンプルAPIレスポンス
    2. 2. APIレスポンスに対応する構造体の定義
    3. 3. APIレスポンスの処理
    4. 4. 結果
    5. 5. エラー処理の追加
    6. 6. APIレスポンスの動的解析
    7. 7. 応用：複数のユーザーを取得する場合
  8. 演習問題：JSON変換の実践例
    1. 問題1: 単純なJSONデータの構造体変換
    2. 問題2: ネストされたJSONデータの解析
    3. 問題3: 動的JSONデータの解析
    4. 問題4: 配列形式のJSONデータの処理
    5. 問題5: エラーハンドリングの実装
    6. 解答の確認
  9. まとめ

JSONとGoの基本概念


JSON（JavaScript Object Notation）は、軽量で人間が読みやすく、機械でも解析しやすいデータ交換フォーマットです。多くのプログラミング言語でサポートされており、特にWeb APIや設定ファイルなどで広く使われています。

JSONの基本構造


JSONデータは主に以下のような形式で構成されます：

  • オブジェクト：キーと値のペア（例：{"key": "value"}）
  • 配列：値のリスト（例：[1, 2, 3]）
  • プリミティブ型：文字列、数値、ブール値、null

GoとJSONの相性


Goでは、JSONデータを処理するためにencoding/jsonパッケージが標準ライブラリとして用意されています。このパッケージにより、JSONを簡単に読み書きできるだけでなく、Goの構造体やマップと組み合わせることで、型安全かつ効率的にデータを操作できます。

JSONとGo構造体の対応


JSONのキーと値は、Goの構造体のフィールドに対応付けられます。例として、以下のJSONデータを考えます：

{
  "name": "Alice",
  "age": 30
}


このデータは、Goでは次のような構造体にマッピングできます：

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

Goマップの利用


動的なキーを持つJSONデータは、Goのmap[string]interface{}として読み取ることができます。これにより、特定の型に依存せず柔軟にJSONデータを扱うことが可能です。

これらの基本を理解することで、GoでJSONを操作するための土台が築かれます。次のセクションでは、json.Unmarshalを使用した具体的な変換方法について学びます。

`json.Unmarshal`の基本構文と動作原理

Go言語において、json.UnmarshalはJSON文字列をGoのデータ構造（構造体やマップなど）に変換するための関数です。このセクションでは、json.Unmarshalの基本的な構文と動作の仕組みについて解説します。

基本構文


json.Unmarshalの基本的な構文は以下の通りです：

func Unmarshal(data []byte, v interface{}) error
  • data: JSON形式のデータ（バイトスライス）
  • v: デコードした結果を格納するためのポインタ（構造体やマップ）
  • error: JSONの解析中に発生したエラーを返す

使用例

1. 構造体に変換する場合


以下の例では、JSON文字列をGoの構造体にデコードします：

package main

import (
    "encoding/json"
    "fmt"
)

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

func main() {
    jsonStr := `{"name": "Alice", "age": 30}`

    var person Person
    err := json.Unmarshal([]byte(jsonStr), &person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Name:", person.Name)
    fmt.Println("Age:", person.Age)
}

出力:

Name: Alice  
Age: 30

2. マップに変換する場合


マップを使用すると、動的なJSONデータに対応できます：

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `{"name": "Alice", "age": 30}`

    var data map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Name:", data["name"])
    fmt.Println("Age:", data["age"])
}

出力:

Name: Alice  
Age: 30

動作原理


json.Unmarshalは次のように動作します：

  1. JSONデータをパースし、構文を検証します。
  2. Goのデータ型（構造体やマップ）に基づいてJSONデータをマッピングします。
  3. 対象のフィールドにデータを割り当てます。タグ（例：json:"name"）が指定されている場合はその名称に従います。

エラーの扱い


不正なJSONやデータ型の不一致がある場合、エラーが返されます。エラーを正しく処理することで、予期しない動作を防ぐことが重要です。

if err != nil {
    fmt.Println("Failed to parse JSON:", err)
}

次のセクションでは、json.Unmarshalを使った構造体への具体的な変換手順について詳しく解説します。

JSONをGo構造体に変換する手順

JSONをGoの構造体に変換することで、型安全なデータ操作が可能になります。このセクションでは、json.Unmarshalを使用してJSONデータをGo構造体に変換する具体的な手順を詳しく解説します。

1. 構造体の定義


まず、JSONデータに対応するGo構造体を定義します。構造体フィールドにはタグ（例：json:"fieldName"）を付与し、JSONキーとフィールド名の対応を設定します。

例: 以下のJSONデータを変換する場合を考えます。

{
  "name": "Alice",
  "age": 30,
  "email": "alice@example.com"
}

対応する構造体の定義：

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

2. JSON文字列の用意


次に、JSONデータを文字列形式で準備します。このデータはjson.Unmarshalで解析されます。

jsonStr := `{"name": "Alice", "age": 30, "email": "alice@example.com"}`

3. `json.Unmarshal`を使用してデコード


json.Unmarshalを使って、JSON文字列を構造体に変換します。この際、構造体のポインタを渡す必要があります。

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // JSON文字列
    jsonStr := `{"name": "Alice", "age": 30, "email": "alice@example.com"}`

    // 構造体
    var person Person

    // デコード処理
    err := json.Unmarshal([]byte(jsonStr), &person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // 結果の表示
    fmt.Println("Name:", person.Name)
    fmt.Println("Age:", person.Age)
    fmt.Println("Email:", person.Email)
}

4. 結果


上記のコードを実行すると、以下のようにデコードされたデータが表示されます：

Name: Alice  
Age: 30  
Email: alice@example.com

5. 応用例：オプションフィールドの処理


一部のフィールドが省略可能な場合、構造体でゼロ値やポインタ型を使用することが推奨されます。

type Person struct {
    Name  string  `json:"name"`
    Age   int     `json:"age"`
    Email *string `json:"email"` // ポインタ型で扱う
}

JSONに"email"キーが存在しない場合、Emailフィールドはnilになります。これにより、動的なデータに対応可能です。

次のセクションでは、JSONをGoのマップに変換する方法について説明します。

JSONをGoマップに変換する手順

JSONデータをGoのマップに変換することで、柔軟で動的なデータ操作が可能になります。このセクションでは、json.Unmarshalを用いてJSONをマップ形式に変換する方法を解説します。

1. Goマップの基本構造


Goのマップは、キーと値のペアを持つデータ構造で、JSONのオブジェクト形式と対応します。JSONをGoのマップに変換する際は、次の形式がよく使われます：

map[string]interface{}
  • キーは常に文字列型（string）
  • 値はinterface{}型（任意の型を受け入れる）

2. JSONデータの準備


次のJSONデータを例にします：

{
  "name": "Alice",
  "age": 30,
  "email": "alice@example.com"
}

このデータをGoのマップに変換します。

3. `json.Unmarshal`を使った変換


以下のコードでは、JSONをマップ形式に変換する手順を示します：

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // JSON文字列
    jsonStr := `{"name": "Alice", "age": 30, "email": "alice@example.com"}`

    // マップ型の変数を用意
    var data map[string]interface{}

    // デコード処理
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // 結果の表示
    fmt.Println("Name:", data["name"])
    fmt.Println("Age:", data["age"])
    fmt.Println("Email:", data["email"])
}

4. 結果


実行すると以下のような出力が得られます：

Name: Alice  
Age: 30  
Email: alice@example.com

5. 値の型変換


map[string]interface{}で扱う値はinterface{}型で格納されるため、特定の型に変換する必要があります。例として、Ageフィールドを整数型に変換する方法を示します：

age, ok := data["age"].(float64) // JSON数値はデフォルトでfloat64として扱われる
if ok {
    fmt.Println("Age as integer:", int(age))
}

6. 動的な構造を持つJSONの処理


ネストされたJSONもマップとして再帰的に扱えます：

{
  "name": "Alice",
  "details": {
    "age": 30,
    "email": "alice@example.com"
  }
}

対応するコード：

jsonStr := `{"name": "Alice", "details": {"age": 30, "email": "alice@example.com"}}`
var data map[string]interface{}
json.Unmarshal([]byte(jsonStr), &data)

// ネストされたマップへのアクセス
details := data["details"].(map[string]interface{})
fmt.Println("Age:", details["age"])
fmt.Println("Email:", details["email"])

7. マップと構造体の使い分け

  • マップは、動的なデータ構造やキーが未知の場合に適しています。
  • 構造体は、事前にデータの形式が決まっている場合に適しています。

次のセクションでは、複雑なネスト構造を持つJSONデータの処理について解説します。

ネストされたJSONの取り扱い

ネストされたJSONは、複雑なデータ構造を扱う際に頻繁に登場します。このセクションでは、GoでネストされたJSONを処理する方法を、構造体とマップの両方を用いて解説します。

1. JSONデータの例


次のようなネストされたJSONデータを例にします：

{
  "name": "Alice",
  "details": {
    "age": 30,
    "contact": {
      "email": "alice@example.com",
      "phone": "123-456-7890"
    }
  }
}

2. 構造体を使った処理


ネストされたJSONに対応するために、Goでは構造体を入れ子にして定義します。

構造体の定義

type Contact struct {
    Email string `json:"email"`
    Phone string `json:"phone"`
}

type Details struct {
    Age     int     `json:"age"`
    Contact Contact `json:"contact"`
}

type Person struct {
    Name    string  `json:"name"`
    Details Details `json:"details"`
}

変換とデータへのアクセス

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // JSONデータ
    jsonStr := `{
        "name": "Alice",
        "details": {
            "age": 30,
            "contact": {
                "email": "alice@example.com",
                "phone": "123-456-7890"
            }
        }
    }`

    // 構造体の初期化
    var person Person

    // JSONをデコード
    err := json.Unmarshal([]byte(jsonStr), &person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // データの表示
    fmt.Println("Name:", person.Name)
    fmt.Println("Age:", person.Details.Age)
    fmt.Println("Email:", person.Details.Contact.Email)
    fmt.Println("Phone:", person.Details.Contact.Phone)
}

結果

Name: Alice  
Age: 30  
Email: alice@example.com  
Phone: 123-456-7890

3. マップを使った処理


JSONキーが動的であり事前に構造体を定義できない場合、マップを使用します。

変換とネストデータへのアクセス

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // JSONデータ
    jsonStr := `{
        "name": "Alice",
        "details": {
            "age": 30,
            "contact": {
                "email": "alice@example.com",
                "phone": "123-456-7890"
            }
        }
    }`

    // マップの初期化
    var data map[string]interface{}

    // JSONをデコード
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // ネストされたデータへのアクセス
    details := data["details"].(map[string]interface{})
    contact := details["contact"].(map[string]interface{})

    fmt.Println("Name:", data["name"])
    fmt.Println("Age:", details["age"])
    fmt.Println("Email:", contact["email"])
    fmt.Println("Phone:", contact["phone"])
}

結果

Name: Alice  
Age: 30  
Email: alice@example.com  
Phone: 123-456-7890

4. 構造体とマップの選択基準

  • 構造体を使用: JSONデータの構造が固定で明確な場合に適しています。型安全で、コードの可読性が高まります。
  • マップを使用: JSONのキーが動的、または未知の場合に適しています。柔軟性があり、キーの存在を動的に確認できます。

次のセクションでは、json.Unmarshalを使用する際のエラーハンドリングとデバッグのポイントについて解説します。

エラーハンドリングとデバッグのポイント

json.Unmarshalを使用してJSONをデコードする際、正確にデータを変換することが重要です。しかし、不正なJSONや型の不一致などでエラーが発生する場合があります。このセクションでは、エラーハンドリングの方法とデバッグのポイントを解説します。

1. エラーの基本的な検出方法


json.Unmarshalは、エラーを返す可能性がある関数です。そのため、エラーを正確にキャッチし、適切に対処する必要があります。

err := json.Unmarshal([]byte(jsonData), &target)
if err != nil {
    fmt.Println("Failed to parse JSON:", err)
    return
}

主なエラー例

  • 不正なJSON: JSONの構文エラー（例: 中括弧やカンマが欠けている）。
  • 型の不一致: Go構造体の型とJSONデータの型が一致しない。
  • 対応するフィールドがない: JSONデータに存在しないキーが構造体にある場合。

2. JSON構文エラーの対処


構文エラーが発生する場合、JSONデータそのものが問題です。エラーの内容を確認して修正します。
例: 不正なJSON

{ "name": "Alice", "age": 30, }

この例では、末尾のカンマが原因でエラーが発生します。エラーを明確に表示することで、問題を特定しやすくなります。

3. 型の不一致エラーの対処


json.UnmarshalはGoの型安全性を利用するため、JSONデータとGo構造体の型が一致しない場合にエラーが発生します。

例: 型の不一致

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

jsonData := `{"name": "Alice", "age": "thirty"}`

エラー:

json: cannot unmarshal string into Go struct field Person.age of type int

解決策


型が一致するようにJSONデータを修正するか、柔軟に処理するためにinterface{}を使用します。

type Person struct {
    Name string      `json:"name"`
    Age  interface{} `json:"age"`
}

4. 欠損フィールドの処理


JSONデータにフィールドが存在しない場合、構造体の該当フィールドにはゼロ値が割り当てられます。この挙動を利用してエラーを回避できます。

例: 欠損フィールドの対処

type Person struct {
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
}
  • omitemptyタグを使用すると、JSONエンコード時にフィールドがスキップされます。
  • 欠損フィールドをポインタ型にすることで、nilチェックが可能です。

5. デバッグのポイント

エラー内容を出力する


エラーが発生した場合、エラーメッセージを詳しく表示して問題の箇所を特定します。

fmt.Printf("Error: %v\n", err)

JSONデータを事前に検証


外部ライブラリ（例: github.com/xeipuuv/gojsonschema）を使ってJSONスキーマ検証を行うことで、事前に問題を防ぐことができます。

デコード結果を確認


デコード後のデータ構造を出力して、意図した内容になっているかを確認します。

fmt.Printf("Decoded data: %+v\n", target)

6. Go Playgroundを活用


JSONデコードに問題がある場合、簡易コードを作成し、Go Playgroundで試してエラーを特定するのも有効です。

次のセクションでは、json.Unmarshalを使ったAPIレスポンス解析の応用例を紹介します。

応用例：APIレスポンスの解析

JSONはWeb APIのデータ形式として広く使用されています。Goを用いることで、APIから受け取ったJSONレスポンスを効率的に解析し、実際のアプリケーションで活用できます。このセクションでは、json.Unmarshalを用いたAPIレスポンスの解析例を示します。

1. サンプルAPIレスポンス


以下は、ユーザー情報を返すAPIの例です：

{
  "status": "success",
  "data": {
    "id": 101,
    "name": "Alice",
    "email": "alice@example.com",
    "age": 30
  }
}

2. APIレスポンスに対応する構造体の定義


JSONレスポンスを解析するには、まずGoの構造体を定義します。

type UserData struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
    Age   int    `json:"age"`
}

type APIResponse struct {
    Status string   `json:"status"`
    Data   UserData `json:"data"`
}

3. APIレスポンスの処理


以下の例では、JSONレスポンスを解析し、ユーザー情報を取得します。

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {
    // ダミーAPI URL（実際のAPI URLを使用してください）
    apiURL := "https://api.example.com/user/101"

    // HTTPリクエストを送信
    resp, err := http.Get(apiURL)
    if err != nil {
        fmt.Println("Error making HTTP request:", err)
        return
    }
    defer resp.Body.Close()

    // レスポンスの読み取り
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    // JSONを構造体にデコード
    var apiResponse APIResponse
    err = json.Unmarshal(body, &apiResponse)
    if err != nil {
        fmt.Println("Error decoding JSON:", err)
        return
    }

    // 結果の表示
    fmt.Println("Status:", apiResponse.Status)
    fmt.Println("User ID:", apiResponse.Data.ID)
    fmt.Println("Name:", apiResponse.Data.Name)
    fmt.Println("Email:", apiResponse.Data.Email)
    fmt.Println("Age:", apiResponse.Data.Age)
}

4. 結果


APIレスポンスが成功した場合、次のような出力が得られます：

Status: success  
User ID: 101  
Name: Alice  
Email: alice@example.com  
Age: 30

5. エラー処理の追加


APIレスポンスがエラーの場合に備えて、エラーフィールドを処理する構造体を追加するのが良い習慣です。

type ErrorResponse struct {
    Status  string `json:"status"`
    Message string `json:"message"`
}

解析コードを修正して、ステータスに応じた処理を追加します。

if apiResponse.Status != "success" {
    var errorResponse ErrorResponse
    json.Unmarshal(body, &errorResponse)
    fmt.Println("Error:", errorResponse.Message)
    return
}

6. APIレスポンスの動的解析


構造体を使わず、map[string]interface{}を用いて動的にデータを解析する方法もあります。この方法はレスポンス形式が固定されていない場合に有効です。

var data map[string]interface{}
json.Unmarshal(body, &data)

fmt.Println("Status:", data["status"])
fmt.Println("Name:", data["data"].(map[string]interface{})["name"])

7. 応用：複数のユーザーを取得する場合


JSONレスポンスが配列形式で複数のデータを返す場合、構造体スライスを使って処理します。

{
  "status": "success",
  "data": [
    {"id": 101, "name": "Alice", "email": "alice@example.com", "age": 30},
    {"id": 102, "name": "Bob", "email": "bob@example.com", "age": 25}
  ]
}

対応する構造体：

type MultiUserResponse struct {
    Status string     `json:"status"`
    Data   []UserData `json:"data"`
}

次のセクションでは、学んだ内容を実践的に試せる演習問題を紹介します。

演習問題：JSON変換の実践例

これまで学んだ内容を応用するために、実際にJSONデータをGoで処理する演習問題を用意しました。これらを解くことで、JSONの変換スキルを実践的に磨けます。

問題1: 単純なJSONデータの構造体変換


以下のJSONデータを構造体に変換し、各フィールドの値を出力してください：

{
  "product": "Laptop",
  "price": 1200.50,
  "stock": 15
}

要求:

  1. Product（文字列型）、Price（浮動小数点型）、Stock（整数型）を持つ構造体を定義してください。
  2. JSONをデコードしてフィールドの値を表示してください。

ヒント:
構造体定義の例:

type Item struct {
    Product string  `json:"product"`
    Price   float64 `json:"price"`
    Stock   int     `json:"stock"`
}

問題2: ネストされたJSONデータの解析


以下のJSONデータを解析して、userの名前とpreferencesのテーマを出力してください：

{
  "user": {
    "id": 42,
    "name": "Charlie"
  },
  "preferences": {
    "theme": "dark",
    "notifications": true
  }
}

要求:

  1. ネストされたJSONに対応する構造体を定義してください。
  2. JSONをデコードし、指定されたフィールドを出力してください。

ヒント:
構造体をネストして定義する方法を参考にしてください。

問題3: 動的JSONデータの解析


以下のJSONデータをmap[string]interface{}を使って解析し、ageフィールドが存在すればその値を出力してください：

{
  "name": "Dana",
  "details": {
    "age": 28,
    "email": "dana@example.com"
  }
}

要求:

  1. map[string]interface{}を使用してデータを解析してください。
  2. detailsの中にageフィールドがある場合、その値を出力してください。

ヒント:

  • 型アサーション（.(type)）を使って、データの型を確認してください。
  • ネストされたマップのアクセス方法を復習してください。

問題4: 配列形式のJSONデータの処理


以下のJSONデータを解析して、各ユーザーの名前を出力してください：

{
  "status": "success",
  "users": [
    {"id": 101, "name": "Alice"},
    {"id": 102, "name": "Bob"},
    {"id": 103, "name": "Charlie"}
  ]
}

要求:

  1. JSONレスポンスに対応する構造体を定義してください。
  2. スライスを使って、全てのユーザーのnameフィールドを出力してください。

ヒント:
スライスを使った構造体の定義例:

type Response struct {
    Status string `json:"status"`
    Users  []User `json:"users"`
}
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

問題5: エラーハンドリングの実装


次のJSONデータを解析するプログラムを作成してください。ただし、JSONが不正な場合は、エラーメッセージを出力して終了する処理を追加してください：

{
  "title": "Introduction to Go",
  "pages": "two hundred"
}

要求:

  1. Title（文字列型）とPages（整数型）を持つ構造体を定義してください。
  2. デコード中にエラーが発生した場合、エラー内容を出力してください。

解答の確認


これらの問題を解いた後、Go Playgroundを使ってコードを動かしてみましょう。また、エラーが発生した場合には、デバッグの方法を復習してください。

次のセクションでは、本記事の内容を振り返り、重要なポイントを整理します。

まとめ

本記事では、GoにおけるJSONデータの処理方法について、基本的なjson.Unmarshalの使い方から応用例までを解説しました。以下が重要なポイントです：

  1. JSONとGoの基本概念: JSONは軽量なデータ交換フォーマットであり、Goでは構造体やマップを使って簡単に操作できます。
  2. 構造体とマップの使い分け: 固定のデータ構造には構造体、動的データにはマップを使用するのが効果的です。
  3. エラーハンドリング: デコード時のエラーを適切に処理し、デバッグ方法を理解しておくことが重要です。
  4. 応用例と演習: APIレスポンス解析やネストされたデータの取り扱いを通じて、実践的なスキルを習得しました。

JSON処理はWebアプリケーションやデータ分析など、さまざまな場面で必須のスキルです。本記事で学んだ内容を活用し、さらに複雑なJSONデータの処理やパフォーマンスの向上を目指してください。

Go
JSON データ変換 Go言語

コメント

コメントする

目次
  1. JSONとGoの基本概念
    1. JSONの基本構造
    2. GoとJSONの相性
  2. `json.Unmarshal`の基本構文と動作原理
    1. 基本構文
    2. 使用例
    3. 動作原理
    4. エラーの扱い
  3. JSONをGo構造体に変換する手順
    1. 1. 構造体の定義
    2. 2. JSON文字列の用意
    3. 3. `json.Unmarshal`を使用してデコード
    4. 4. 結果
    5. 5. 応用例：オプションフィールドの処理
  4. JSONをGoマップに変換する手順
    1. 1. Goマップの基本構造
    2. 2. JSONデータの準備
    3. 3. `json.Unmarshal`を使った変換
    4. 4. 結果
    5. 5. 値の型変換
    6. 6. 動的な構造を持つJSONの処理
    7. 7. マップと構造体の使い分け
  5. ネストされたJSONの取り扱い
    1. 1. JSONデータの例
    2. 2. 構造体を使った処理
    3. 3. マップを使った処理
    4. 4. 構造体とマップの選択基準
  6. エラーハンドリングとデバッグのポイント
    1. 1. エラーの基本的な検出方法
    2. 2. JSON構文エラーの対処
    3. 3. 型の不一致エラーの対処
    4. 4. 欠損フィールドの処理
    5. 5. デバッグのポイント
    6. 6. Go Playgroundを活用
  7. 応用例：APIレスポンスの解析
    1. 1. サンプルAPIレスポンス
    2. 2. APIレスポンスに対応する構造体の定義
    3. 3. APIレスポンスの処理
    4. 4. 結果
    5. 5. エラー処理の追加
    6. 6. APIレスポンスの動的解析
    7. 7. 応用：複数のユーザーを取得する場合
  8. 演習問題：JSON変換の実践例
    1. 問題1: 単純なJSONデータの構造体変換
    2. 問題2: ネストされたJSONデータの解析
    3. 問題3: 動的JSONデータの解析
    4. 問題4: 配列形式のJSONデータの処理
    5. 問題5: エラーハンドリングの実装
    6. 解答の確認
  9. まとめ