JSONでの配列の使い方（コード例付き）

はじめに

JSON（JavaScript Object Notation）は、システム間で構造化された情報を伝送するために最も広く使用されているデータフォーマットの一つです。そのコアビルディングブロックの一つが配列で、文字列、数値、オブジェクト、さらには他の配列などのデータの順序付きリストを表現することができます。

設定ファイルを定義したり、APIにデータを送信したり、サーバーのレスポンスを処理したりする際に、JSONでの配列の使い方を理解することは不可欠です。このガイドでは、配列の動作、定義方法、コード内でのアクセス方法、オブジェクトの配列のようなより複雑なケースの処理方法について説明します。

JSONにおける配列とは？

JSON配列は、角括弧[]で囲まれた順序付きリストです。文字列、数値、ブール値、オブジェクト、または他の配列など、任意の値の組み合わせを保持できます。

• 文字列
• 数値
• ブール値
• オブジェクト
• 他の配列
• null

例：文字列の配列

{
  "colors": ["red", "green", "blue"]
}

JSONオブジェクトの配列

JSONの最も強力なパターンの一つがオブジェクトの配列です。これは、ユーザー、製品、または注文のリストのような構造化データのコレクションを表現するために使用されます。

例：オブジェクトの配列

{
  "users": [
    { "id": 1, "name": "Alice", "email": "alice@example.com" },
    { "id": 2, "name": "Bob", "email": "bob@example.com" }
  ]
}

JSONの配列の配列

JSONの配列の配列は、外側の配列内の各アイテムが自身も配列であるネストされたデータ構造です。この構造は、表形式データ、行列、または座標セットを表現するためによく使用され、各内側の配列は関連する値のグループを保持します。

例：行列（2Dグリッド）

{
  "matrix": [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
  ]
}

例：座標

{
  "coordinates": [
    [35.6895, 139.6917],     // 東京
    [34.0522, -118.2437],    // ロサンゼルス
    [51.5074, -0.1278]       // ロンドン
  ]
}

人気のある言語でのJSON配列の操作方法

JSON文字列をネイティブデータ構造に解析したら、言語の組み込みツールを使って簡単にループ、フィルタ、マップ、または修正できます。

以下は、最も人気のある言語のいくつかでの例です：

1. JavaScript/TypeScriptでのJSON配列の操作

JSON配列は、JavaScriptやTypeScriptで構造化データを扱うために広く使用されており、特にAPIレスポンス、ローカルストレージ、データベース、または動的UIレンダリングでの作業において重要です。これらを効果的に操作する方法を理解することは、クリーンで効率的なコードを書くための鍵です。

JSON配列を扱う際によく必要となる一般的な操作は以下の通りです：

// サンプルJSONオブジェクトの配列
const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false },
  { name: "Carol", active: true }
];

// 1. 配列をループする
users.forEach(user => {
  console.log("ユーザー名:", user.name);
});

// 2. アイテムをフィルタする
const activeUsers = users.filter(user => user.active);
console.log("アクティブユーザー:", activeUsers);

// 3. 名前でソートする
const sortedUsers = [...users].sort((a, b) => a.name.localeCompare(b.name));
console.log("ソートされたユーザー:", sortedUsers);

// 4. 新しいアイテムを追加する
users.push({ name: "Dave", active: true });
console.log("Daveを追加した後:", users);

// 5. インデックスでアイテムを削除する（例：2番目のユーザーを削除）
users.splice(1, 1);
console.log("2番目のユーザーを削除した後:", users);

// 6. 名前でユーザーを見つける
const foundUser = users.find(user => user.name === "Alice");
console.log("見つかったユーザー:", foundUser);

// 7. 配列内のオブジェクトを更新する（例：Bobをアクティブにする）
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("更新されたユーザー:", updatedUsers);

// 8. 配列をJSON文字列に変換する
const jsonString = JSON.stringify(users);
console.log("JSON文字列:", jsonString);

// 9. JSON文字列を配列に戻す
const parsedUsers = JSON.parse(jsonString);
console.log("解析されたユーザー:", parsedUsers);

2. PythonでのJSON配列の操作

Pythonでは、JSON配列は通常リストとして表現され、JSONオブジェクトは辞書として表現されます。Pythonの組み込みのjsonモジュールを使うと、APIレスポンスを消費したり、設定ファイルを読み込んだり、構造化データをエクスポート用に準備したりする際に、JSONデータを簡単に扱うことができます。

辞書のリスト（つまり、オブジェクトのJSON配列）を使用することは、Pythonでデータを扱う際の一般的なパターンです。この構造は柔軟で強力であり、フィルタリング、ソート、更新、シリアライズなどの操作を、リスト内包表記、sorted()、辞書のアンパックなどのPythonのネイティブな機能を使って簡単に行うことができます。

import json

# サンプルJSONオブジェクトの配列（Pythonの辞書のリスト）
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. 配列をループする
for user in users:
    print("ユーザー名:", user["name"])

# 2. アイテムをフィルタする
active_users = [user for user in users if user["active"]]
print("アクティブユーザー:", active_users)

# 3. 名前でソートする
sorted_users = sorted(users, key=lambda user: user["name"])
print("ソートされたユーザー:", sorted_users)

# 4. 新しいアイテムを追加する
users.append({ "name": "Dave", "active": True })
print("Daveを追加した後:", users)

# 5. インデックスでアイテムを削除する（例：2番目のユーザーを削除）
users.pop(1)
print("2番目のユーザーを削除した後:", users)

# 6. 名前でユーザーを見つける
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("見つかったユーザー:", found_user)

# 7. 配列内のオブジェクトを更新する（例：Bobをアクティブにする）
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("更新されたユーザー:", updated_users)

# 8. 配列をJSON文字列に変換する
json_string = json.dumps(users)
print("JSON文字列:", json_string)

# 9. JSON文字列を配列に戻す
parsed_users = json.loads(json_string)
print("解析されたユーザー:", parsed_users)

3. JavaでのJSON配列の操作

Javaでは、JSON配列は通常、Jackson、Gson、またはorg.jsonのようなライブラリを使用してList<Map<String, Object>>として表現されます。これらのライブラリを使用すると、JSONデータを簡単に解析、生成、操作できます。

JavaでJSON配列を操作することは、REST APIレスポンス、データストレージ、または設定ファイルを扱う際に重要です。Javaは静的型付けの言語であるため、JSONデータをPOJO（Plain Old Java Objects）にマッピングする必要があることが多いですが、構造が動的な場合はListやMapのような柔軟な型を使用することもあります。

例（Jacksonを使用）

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.*;
import java.util.stream.Collectors;

public class JsonArrayExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        // サンプルJSON文字列
        String json = "[{\"name\":\"Alice\",\"active\":true},{\"name\":\"Bob\",\"active\":false},{\"name\":\"Carol\",\"active\":true}]";

        // 1. JSON文字列をList of Mapに解析する
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("元のユーザー: " + users);

        // 2. 配列をループする
        for (Map<String, Object> user : users) {
            System.out.println("ユーザー名: " + user.get("name"));
        }

        // 3. アクティブユーザーをフィルタする
        List<Map<String, Object>> activeUsers = users.stream()
                .filter(user -> Boolean.TRUE.equals(user.get("active")))
                .collect(Collectors.toList());
        System.out.println("アクティブユーザー: " + activeUsers);

        // 4. 名前でソートする
        users.sort(Comparator.comparing(user -> (String) user.get("name")));
        System.out.println("ソートされたユーザー: " + users);

        // 5. 新しいユーザーを追加する
        Map<String, Object> newUser = new HashMap<>();
        newUser.put("name", "Dave");
        newUser.put("active", true);
        users.add(newUser);
        System.out.println("Daveを追加した後: " + users);

        // 6. インデックスでユーザーを削除する
        users.remove(1);
        System.out.println("2番目のユーザーを削除した後: " + users);

        // 7. 名前でユーザーを見つける
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("見つかったユーザー: " + found);

        // 8. Bobをアクティブにする（存在する場合）
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. リストをJSON文字列に戻す
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("更新されたJSON文字列: " + updatedJson);
    }
}

4. PHPでのJSON配列の操作

PHPでは、JSON配列は通常、連想配列（JSONオブジェクト用）またはインデックス配列（JSONリスト用）にデコードされます。PHPは、json_decode()やjson_encode()などの組み込み関数を提供しており、JSONデータを解析およびシリアライズすることができ、JSON構造を直接操作するのが簡単です。

オブジェクトの配列（つまり、連想配列のJSON配列）を扱うことは、APIレスポンス、設定ファイル、またはAJAX呼び出しを扱う際の一般的なパターンです。PHPの柔軟な配列構造は、フィルタリング、ソート、更新、JSON配列のシリアライズなどの操作を非常に便利に行うことができます。

<?php

// サンプルJSON文字列
$json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]';

// 1. JSON文字列をPHP配列にデコードする
$users = json_decode($json, true);
echo "元のユーザー:\n";
print_r($users);

// 2. 配列をループする
foreach ($users as $user) {
    echo "ユーザー名: " . $user['name'] . "\n";
}

// 3. アクティブユーザーをフィルタする
$activeUsers = array_filter($users, function ($user) {
    return $user['active'] === true;
});
echo "アクティブユーザー:\n";
print_r($activeUsers);

// 4. 名前でユーザーをソートする
usort($users, function ($a, $b) {
    return strcmp($a['name'], $b['name']);
});
echo "ソートされたユーザー:\n";
print_r($users);

// 5. 新しいユーザーを追加する
$users[] = ["name" => "Dave", "active" => true];
echo "Daveを追加した後:\n";
print_r($users);

// 6. インデックスでユーザーを削除する（例：2番目のユーザーを削除）
array_splice($users, 1, 1);
echo "2番目のユーザーを削除した後:\n";
print_r($users);

// 7. 名前でユーザーを見つける
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "見つかったユーザー:\n";
print_r($foundUser);

// 8. Bobをアクティブにする（存在する場合）
foreach ($users as &$user) {
    if ($user['name'] === 'Bob') {
        $user['active'] = true;
    }
}
unset($user); // 参照を解除

// 9. JSONに戻す
$updatedJson = json_encode($users, JSON_PRETTY_PRINT);
echo "更新されたJSON:\n";
echo $updatedJson;

5. RubyでのJSON配列の操作

Rubyでは、JSON配列は通常、組み込みのjsonライブラリを使用してハッシュの配列に解析されます。この構造は、APIレスポンス、設定ファイル、およびあらゆる構造化データ交換を扱うのに最適です。Rubyの表現力豊かな構文と列挙メソッド（each、select、sort_by、mapなど）を使用すると、JSON配列を非常に便利に操作できます。

require 'json'

# サンプルJSON文字列
json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]'

# 1. JSON文字列をRubyのハッシュの配列に解析する
users = JSON.parse(json)
puts "元のユーザー:"
puts users

# 2. 配列をループする
users.each do |user|
  puts "ユーザー名: #{user['name']}"
end

# 3. アクティブユーザーをフィルタする
active_users = users.select { |user| user['active'] }
puts "アクティブユーザー:"
puts active_users

# 4. 名前でユーザーをソートする
sorted_users = users.sort_by { |user| user['name'] }
puts "ソートされたユーザー:"
puts sorted_users

# 5. 新しいユーザーを追加する
users << { 'name' => 'Dave', 'active' => true }
puts "Daveを追加した後:"
puts users

# 6. インデックスでユーザーを削除する（例：2番目のユーザーを削除）
users.delete_at(1)
puts "2番目のユーザーを削除した後:"
puts users

# 7. 名前でユーザーを見つける
found_user = users.find { |user| user['name'] == 'Alice' }
puts "見つかったユーザー:"
puts found_user

# 8. Bobをアクティブにする（存在する場合）
users.map! do |user|
  user['name'] == 'Bob' ? user.merge('active' => true) : user
end

# 9. JSON文字列に戻す
updated_json = JSON.pretty_generate(users)
puts "更新されたJSON文字列:"
puts updated_json

6. GolangでのJSON配列の操作

Goでは、JSON配列は通常、スライスの構造体または動的構造用の[]map[string]interface{}にデコードされます。encoding/jsonパッケージは、JSONのエンコード/デコードを行うための強力で柔軟なツールを提供します。JSON操作は、REST API、設定ファイル、またはデータ変換を扱う際にGoで一般的です。

Goの厳密な型付けとパフォーマンスは、構造化データのカスタム型を定義する際に特に理想的です。以下は、GoでのJSON配列の操作を示す完全な例で、解析、ループ、フィルタリング、ソート、更新、JSONへの変換をカバーしています。

package main

import (
	"encoding/json"
	"fmt"
	"sort"
)

type User struct {
	Name   string `json:"name"`
	Active bool   `json:"active"`
}

func main() {
	// サンプルJSON配列
	jsonStr := `[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]`

	// 1. JSON文字列を構造体のスライスに解析する
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("元のユーザー:", users)

	// 2. 配列をループする
	for _, user := range users {
		fmt.Println("ユーザー名:", user.Name)
	}

	// 3. アクティブユーザーをフィルタする
	var activeUsers []User
	for _, user := range users {
		if user.Active {
			activeUsers = append(activeUsers, user)
		}
	}
	fmt.Println("アクティブユーザー:", activeUsers)

	// 4. 名前でユーザーをソートする
	sort.Slice(users, func(i, j int) bool {
		return users[i].Name < users[j].Name
	})
	fmt.Println("ソートされたユーザー:", users)

	// 5. 新しいユーザーを追加する
	users = append(users, User{Name: "Dave", Active: true})
	fmt.Println("Daveを追加した後:", users)

	// 6. インデックスでユーザーを削除する（例：2番目のユーザーを削除）
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("2番目のユーザーを削除した後:", users)

	// 7. 名前でユーザーを見つける
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("見つかったユーザー:", found)

	// 8. Bobをアクティブにする（存在する場合）
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. スライスをJSONに戻す
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("更新されたJSON:")
	fmt.Println(string(updatedJSON))
}

JSON配列を扱うための便利なオンラインツール

1. CodeUtility: JSONビューワー/整形ツール

• 行番号付きで自動フォーマットします。
• コンパクトビューとプレティビューモードを切り替えます。
• 組み込みのバリデーション機能があります。

リンク: https://beautifyjson.codeutility.io

2. CodeUtility: JSONからYAMLへ

• JSON配列をYAMLに変換します。
• 配列フィールドをフィルタまたは抽出します。

リンク: https://json2yaml.codeutility.io

3. JSONLint: JSONバリデーター

• JSONを検証し、フォーマットします。
• JSON配列が構文的に正しいか確認します。
• 自動インデントとエラーのハイライトを行います。

リンク: https://jsonlint.com