Как использовать массивы в 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. Манипуляция массивами JSON в JavaScript/TypeScript

Массивы 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("После добавления Дэйва:", users);

// 5. Удаление элемента по индексу (например, удалить второго пользователя)
users.splice(1, 1);
console.log("После удаления второго пользователя:", users);

// 6. Поиск пользователя по имени
const foundUser = users.find(user => user.name === "Alice");
console.log("Найденный пользователь:", foundUser);

// 7. Обновление объекта в массиве (например, установить Боба в активные, если он существует)
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. Манипуляция массивами JSON в Python

В Python массивы JSON обычно представлены как списки, а объекты JSON как словари. Встроенный модуль json в Python упрощает работу с данными JSON — будь то получение ответов API, чтение конфигурационных файлов или подготовка структурированных данных для экспорта.

Использование списков словарей (т.е. массивов объектов JSON) — это распространенный паттерн при работе с данными в Python. Эта структура является как гибкой, так и мощной, позволяя вам выполнять операции, такие как фильтрация, сортировка, обновление и сериализация, легко с помощью встроенных возможностей Python, таких как списковые выражения, sorted() и распаковка словарей.

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("После добавления Дэйва:", users)

# 5. Удаление элемента по индексу (например, удалить второго пользователя)
users.pop(1)
print("После удаления второго пользователя:", users)

# 6. Поиск пользователя по имени
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("Найденный пользователь:", found_user)

# 7. Обновление объекта в массиве (например, установить Боба в активные, если он существует)
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. Манипуляция массивами JSON в Java

В Java массивы JSON обычно представлены с использованием List<Map<String, Object>> при работе с библиотеками, такими как Jackson, Gson или org.json. Эти библиотеки позволяют вам легко разбирать, генерировать и манипулировать данными JSON.

Манипуляция массивами JSON в Java является необходимой при работе с ответами 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<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("После добавления Дэйва: " + users);

        // 6. Удаление пользователя по индексу
        users.remove(1);
        System.out.println("После удаления второго пользователя: " + users);

        // 7. Поиск пользователя по имени
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("Найденный пользователь: " + found);

        // 8. Обновление Боба до активного (если существует)
        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. Манипуляция массивами JSON в PHP

В 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 "После добавления Дэйва:\n";
print_r($users);

// 6. Удаление пользователя по индексу (например, удалить второго пользователя)
array_splice($users, 1, 1);
echo "После удаления второго пользователя:\n";
print_r($users);

// 7. Поиск пользователя по имени
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "Найденный пользователь:\n";
print_r($foundUser);

// 8. Обновление Боба до активного, если существует
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. Манипуляция массивами JSON в Ruby

В 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 "После добавления Дэйва:"
puts users

# 6. Удаление пользователя по индексу (например, удалить второго пользователя)
users.delete_at(1)
puts "После удаления второго пользователя:"
puts users

# 7. Поиск пользователя по имени
found_user = users.find { |user| user['name'] == 'Alice' }
puts "Найденный пользователь:"
puts found_user

# 8. Обновление Боба до активного (если существует)
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. Манипуляция массивами JSON в Golang

В Go массивы JSON обычно декодируются в срезы структур или []map[string]interface{} для динамических структур. Пакет encoding/json предоставляет мощные и гибкие инструменты для кодирования/декодирования JSON. Манипуляция JSON является обычным делом в Go при работе с REST API, конфигурационными файлами или преобразованием данных.

Строгая типизация и производительность Go делают его идеальным для надежной обработки JSON, особенно при определении пользовательских типов для структурированных данных. Ниже приведен полный пример, демонстрирующий, как манипулировать массивами JSON в Go, охватывающий разбор, перебор, фильтрацию, сортировку, обновление и преобразование обратно в 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("После добавления Дэйва:", users)

	// 6. Удаление пользователя по индексу (например, удалить второго пользователя)
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("После удаления второго пользователя:", users)

	// 7. Поиск пользователя по имени
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("Найденный пользователь:", found)

	// 8. Обновление Боба до активного, если существует
	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 Viewer/Beautifier

• Автоформатирование с номерами строк.
• Переключение между компактным и красивым видом.
• Встроенная проверка.

Ссылка: https://beautifyjson.codeutility.io

2. CodeUtility: JSON в Yaml

• Преобразование массива JSON в YAML.
• Фильтрация или извлечение полей массива.

Ссылка: https://json2yaml.codeutility.io

3. JSONLint: Валидатор JSON

• Проверка и форматирование JSON.
• Проверяет, является ли ваш массив JSON синтаксически корректным.
• Автоотступы и выделение ошибок.

Ссылка: https://jsonlint.com