소개

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. 인덱스로 항목 제거 (예: 두 번째 사용자 제거)
users.splice(1, 1);
console.log("두 번째 사용자 제거 후:", 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에서 데이터를 처리할 때 일반적인 패턴입니다. 이 구조는 유연하고 강력하여 필터링, 정렬, 업데이트 및 직렬화와 같은 작업을 쉽게 수행할 수 있게 해줍니다.

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. 인덱스로 항목 제거 (예: 두 번째 사용자 제거)
users.pop(1)
print("두 번째 사용자 제거 후:", 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("두 번째 사용자 제거 후: " + 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. 인덱스로 사용자 제거 (예: 두 번째 사용자 제거)
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. 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. 인덱스로 사용자 제거 (예: 두 번째 사용자 제거)
users.delete_at(1)
puts "두 번째 사용자 제거 후:"
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을 인코딩/디코딩하는 강력하고 유연한 도구를 제공합니다. REST API, 구성 파일 또는 데이터 변환을 처리할 때 Go에서 JSON 조작은 일반적입니다.

Go의 엄격한 타입과 성능은 구조화된 데이터에 대한 사용자 정의 타입을 정의할 때 특히 JSON 처리를 위한 이상적인 환경을 제공합니다. 아래는 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. 인덱스로 사용자 제거 (예: 두 번째 사용자 제거)
	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. 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