วิธีการใช้ Arrays ใน JSON (พร้อมตัวอย่างในโค้ด)

บทนำ

JSON (JavaScript Object Notation) เป็นหนึ่งในรูปแบบข้อมูลที่ใช้กันอย่างแพร่หลายที่สุดสำหรับการส่งข้อมูลที่มีโครงสร้างระหว่างระบบ หนึ่งในส่วนประกอบหลักคือ array ซึ่งช่วยให้คุณสามารถแทนรายการข้อมูลที่เรียงลำดับ เช่น สตริง ตัวเลข อ็อบเจ็กต์ หรือแม้แต่ arrays อื่น ๆ

ไม่ว่าคุณจะกำหนดไฟล์การตั้งค่า ส่งข้อมูลไปยัง API หรือประมวลผลการตอบสนองจากเซิร์ฟเวอร์ การเข้าใจวิธีการใช้ arrays ใน JSON เป็นสิ่งสำคัญ คู่มือนี้จะครอบคลุมวิธีการทำงานของ arrays วิธีการกำหนดเข้าถึงในโค้ด และจัดการกรณีที่ซับซ้อนมากขึ้น เช่น arrays ของอ็อบเจ็กต์

Array ใน JSON คืออะไร?

A JSON array คือรายการที่เรียงลำดับอยู่ในวงเล็บเหลี่ยม []. มันสามารถเก็บค่าผสมใด ๆ รวมถึง:

• Strings
• Numbers
• Booleans
• Objects
• Other arrays
• null

ตัวอย่าง: Array ของสตริง

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

JSON Array ของอ็อบเจ็กต์

หนึ่งในรูปแบบที่ทรงพลังที่สุดใน JSON คือ array ของอ็อบเจ็กต์ ซึ่งใช้เพื่อแทนคอลเลกชันของข้อมูลที่มีโครงสร้าง เช่น รายชื่อผู้ใช้ ผลิตภัณฑ์ หรือคำสั่งซื้อ

ตัวอย่าง: Array ของอ็อบเจ็กต์

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

JSON Array ของ Arrays

A JSON array of arrays คือโครงสร้างข้อมูลที่ซ้อนกัน ซึ่งแต่ละรายการภายใน array ภายนอกก็เป็น array เอง โครงสร้างนี้มักใช้เพื่อแทน ข้อมูลแบบตาราง เมทริกซ์ หรือ ชุดพิกัด ซึ่งแต่ละ array ภายในจะเก็บกลุ่มค่าที่เกี่ยวข้อง

ตัวอย่าง: เมทริกซ์ (2D Grid)

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

ตัวอย่าง: พิกัด

{
  "coordinates": [
    [35.6895, 139.6917],     // โตเกียว
    [34.0522, -118.2437],    // ลอสแอนเจลิส
    [51.5074, -0.1278]       // ลอนดอน
  ]
}

วิธีการจัดการ JSON Arrays ในภาษาโปรดของคุณ?

เมื่อคุณแปลงสตริง JSON เป็นโครงสร้างข้อมูลพื้นเมืองแล้ว คุณสามารถ วนรอบ กรอง แมพ หรือ ปรับเปลี่ยน arrays ได้อย่างง่ายดายโดยใช้เครื่องมือในตัวของภาษา

ด้านล่างนี้คือตัวอย่างในบางภาษาที่ได้รับความนิยมมากที่สุด:

1. จัดการ JSON Arrays ใน JavaScript/TypeScript

JSON arrays ถูกใช้กันอย่างแพร่หลายใน JavaScript และ TypeScript เพื่อจัดการข้อมูลที่มีโครงสร้าง โดยเฉพาะเมื่อทำงานกับการตอบสนองจาก API, การจัดเก็บข้อมูลในท้องถิ่น, ฐานข้อมูล หรือการเรนเดอร์ UI แบบไดนามิก การเข้าใจวิธีการจัดการกับมันอย่างมีประสิทธิภาพเป็นกุญแจสำคัญในการเขียนโค้ดที่สะอาดและมีประสิทธิภาพ

นี่คือตัวอย่างการดำเนินการทั่วไปที่คุณมักจะต้องใช้เมื่อทำงานกับ JSON arrays:

// ตัวอย่าง JSON array ของอ็อบเจ็กต์
const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false },
  { name: "Carol", active: true }
];

// 1. วนรอบผ่าน array
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. อัปเดตอ็อบเจ็กต์ใน array (เช่น ตั้งค่า Bob เป็น active หากเขามีอยู่)
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("ผู้ใช้ที่อัปเดต:", updatedUsers);

// 8. แปลง array เป็นสตริง JSON
const jsonString = JSON.stringify(users);
console.log("สตริง JSON:", jsonString);

// 9. แปลงสตริง JSON กลับเป็น array
const parsedUsers = JSON.parse(jsonString);
console.log("ผู้ใช้ที่แปลงแล้ว:", parsedUsers);

2. จัดการ JSON Arrays ใน Python

ใน Python, JSON arrays มักจะแทนที่ด้วย lists และ JSON objects เป็น dictionaries โมดูล json ในตัวของ Python ทำให้การทำงานกับข้อมูล JSON เป็นเรื่องง่าย ไม่ว่าคุณจะใช้การตอบสนองจาก API, อ่านไฟล์การตั้งค่า, หรือเตรียมข้อมูลที่มีโครงสร้างสำหรับการส่งออก

การใช้ lists ของ dictionaries (คือ JSON arrays ของอ็อบเจ็กต์) เป็นรูปแบบทั่วไปเมื่อจัดการข้อมูลใน Python โครงสร้างนี้มีความยืดหยุ่นและทรงพลัง ทำให้คุณสามารถดำเนินการเช่นการกรอง การเรียงลำดับ การอัปเดต และการจัดเรียงได้อย่างง่ายดายด้วยฟีเจอร์ในตัวของ Python เช่น list comprehensions, sorted(), และ dictionary unpacking

import json

# ตัวอย่าง JSON array ของอ็อบเจ็กต์ (Python list ของ dicts)
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. วนรอบผ่าน array
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. อัปเดตอ็อบเจ็กต์ใน array (เช่น ตั้งค่า Bob เป็น active หากเขามีอยู่)
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("ผู้ใช้ที่อัปเดต:", updated_users)

# 8. แปลง array เป็นสตริง JSON
json_string = json.dumps(users)
print("สตริง JSON:", json_string)

# 9. แปลงสตริง JSON กลับเป็น array
parsed_users = json.loads(json_string)
print("ผู้ใช้ที่แปลงแล้ว:", parsed_users)

3. จัดการ JSON Arrays ใน Java

ใน Java, JSON arrays มักจะแทนที่ด้วย List<Map<String, Object>> เมื่อทำงานกับไลบรารีอย่าง Jackson, Gson, หรือ org.json ไลบรารีเหล่านี้ช่วยให้คุณสามารถแปลง สร้าง และจัดการข้อมูล JSON ได้อย่างง่ายดาย

การจัดการ JSON arrays ใน Java เป็นสิ่งสำคัญเมื่อจัดการกับการตอบสนองจาก REST API, การจัดเก็บข้อมูล, หรือไฟล์การตั้งค่า เนื่องจาก Java เป็นภาษาที่มีการกำหนดประเภทแบบสถิติ คุณมักจะต้องแมพข้อมูล JSON ไปยัง POJOs (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
        String json = "[{\"name\":\"Alice\",\"active\":true},{\"name\":\"Bob\",\"active\":false},{\"name\":\"Carol\",\"active\":true}]";

        // 1. แปลง JSON string เป็น List ของ Map
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("ผู้ใช้ต้นฉบับ: " + users);

        // 2. วนรอบผ่าน array
        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 เป็น active (ถ้ามีอยู่)
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. แปลง list กลับเป็น JSON string
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("สตริง JSON ที่อัปเดต: " + updatedJson);
    }
}

4. จัดการ JSON Arrays ใน PHP

ใน PHP, JSON arrays มักจะถูกถอดรหัสเป็น associative arrays (สำหรับ JSON objects) หรือ indexed arrays (สำหรับ JSON lists) PHP มีฟังก์ชันในตัวเช่น json_decode() และ json_encode() เพื่อแปลงและจัดเรียงข้อมูล JSON ทำให้การจัดการโครงสร้าง JSON เป็นเรื่องง่าย

การทำงานกับ arrays ของอ็อบเจ็กต์ (คือ JSON array ของ associative arrays) เป็นรูปแบบทั่วไปเมื่อจัดการกับการตอบสนองจาก API, ไฟล์การตั้งค่า, หรือการเรียก AJAX โครงสร้าง array ที่ยืดหยุ่นของ PHP ทำให้สะดวกมากในการดำเนินการเช่นการกรอง การเรียงลำดับ การอัปเดต และการจัดเรียง JSON arrays

<?php

// ตัวอย่าง JSON string
$json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]';

// 1. ถอดรหัส JSON string เป็น PHP array
$users = json_decode($json, true);
echo "ผู้ใช้ต้นฉบับ:\n";
print_r($users);

// 2. วนรอบผ่าน array
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 เป็น active หากมีอยู่
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 Arrays ใน Ruby

ใน Ruby, JSON arrays มักจะถูกแปลงเป็น arrays of hashes โดยใช้ไลบรารี json ในตัว โครงสร้างนี้เหมาะสำหรับการทำงานกับการตอบสนองจาก API, ไฟล์การตั้งค่า, และการแลกเปลี่ยนข้อมูลที่มีโครงสร้าง วิธีการที่ชัดเจนของ Ruby และวิธีการ enumerable (each, select, sort_by, map, ฯลฯ) ทำให้การจัดการ JSON arrays เป็นเรื่องสะดวกมาก

require 'json'

# ตัวอย่าง JSON string
json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]'

# 1. แปลง JSON string เป็น Ruby array of hashes
users = JSON.parse(json)
puts "ผู้ใช้ต้นฉบับ:"
puts users

# 2. วนรอบผ่าน array
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 เป็น active (ถ้ามีอยู่)
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 Arrays ใน Golang

ใน Go, JSON arrays มักจะถูกถอดรหัสเป็น slices ของ structs หรือ []map[string]interface{} สำหรับโครงสร้างที่ไดนามิก แพ็กเกจ encoding/json มีเครื่องมือที่ทรงพลังและยืดหยุ่นในการเข้ารหัส/ถอดรหัส JSON การจัดการ JSON เป็นเรื่องปกติใน Go เมื่อจัดการกับ REST APIs, ไฟล์การตั้งค่า, หรือการแปลงข้อมูล

การกำหนดประเภทที่เข้มงวดและประสิทธิภาพของ Go ทำให้เหมาะสำหรับการจัดการ JSON ที่แข็งแกร่ง โดยเฉพาะเมื่อกำหนดประเภทที่กำหนดเองสำหรับข้อมูลที่มีโครงสร้าง ด้านล่างนี้คือตัวอย่างที่สมบูรณ์แสดงวิธีการจัดการ JSON arrays ใน Go รวมถึงการแปลง การวนรอบ การกรอง การเรียงลำดับ การอัปเดต และการแปลงกลับเป็น JSON

package main

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

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

func main() {
	// ตัวอย่าง JSON array
	jsonStr := `[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]`

	// 1. แปลง JSON string เป็น slice ของ structs
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("ผู้ใช้ต้นฉบับ:", users)

	// 2. วนรอบผ่าน array
	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 เป็น active หากมีอยู่
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. แปลง slice กลับเป็น JSON
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON ที่อัปเดต:")
	fmt.Println(string(updatedJSON))
}

เครื่องมือออนไลน์ที่มีประโยชน์สำหรับการทำงานกับ JSON Arrays

1. CodeUtility: JSON Viewer/Beautifier

• จัดรูปแบบอัตโนมัติพร้อมหมายเลขบรรทัด
• สลับระหว่างมุมมองที่กระชับและมุมมองที่สวยงาม
• การตรวจสอบความถูกต้องในตัว

ลิงค์: https://beautifyjson.codeutility.io

2. CodeUtility: JSON to Yaml

• แปลง JSON array เป็น YAML.
• กรองหรือดึงฟิลด์ของ array.

ลิงค์: https://json2yaml.codeutility.io

3. JSONLint: JSON Validator

• ตรวจสอบและจัดรูปแบบ JSON.
• ตรวจสอบว่า JSON array ของคุณถูกต้องตามไวยากรณ์หรือไม่.
• จัดระเบียบอัตโนมัติและเน้นข้อผิดพลาด.

ลิงค์: https://jsonlint.com