JSON में Arrays का उपयोग कैसे करें (कोड में उदाहरण के साथ)

परिचय

JSON (JavaScript Object Notation) सबसे व्यापक रूप से उपयोग किए जाने वाले डेटा प्रारूपों में से एक है जो सिस्टमों के बीच संरचित जानकारी को संप्रेषित करने के लिए उपयोग किया जाता है। इसके मुख्य निर्माण ब्लॉकों में से एक array है, जो आपको डेटा की क्रमबद्ध सूचियों का प्रतिनिधित्व करने की अनुमति देता है, जैसे कि strings, numbers, objects, या यहां तक कि अन्य arrays।

चाहे आप कॉन्फ़िगरेशन फ़ाइलें परिभाषित कर रहे हों, API को डेटा भेज रहे हों, या सर्वर प्रतिक्रियाओं को संसाधित कर रहे हों, JSON में arrays का उपयोग करना समझना आवश्यक है। यह गाइड बताती है कि arrays कैसे काम करते हैं, उन्हें कैसे परिभाषित करें, कोड में उन तक कैसे पहुंचें, और वस्तुओं के arrays जैसे अधिक जटिल मामलों को कैसे संभालें।

JSON में Array क्या है?

JSON array एक क्रमबद्ध सूची है जो वर्ग ब्रैकेट [] में बंद होती है। यह किसी भी संयोजन के मानों को रख सकती है, जिसमें शामिल हैं:

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

उदाहरण: Strings का Array

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

JSON वस्तुओं का Array

JSON में सबसे शक्तिशाली पैटर्नों में से एक objects का array है। इसका उपयोग संरचित डेटा के संग्रह का प्रतिनिधित्व करने के लिए किया जाता है—जैसे कि उपयोगकर्ताओं, उत्पादों, या आदेशों की सूचियाँ।

उदाहरण: वस्तुओं का Array

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

JSON arrays का Array

एक JSON arrays का array एक नेस्टेड डेटा संरचना है जहाँ बाहरी array के अंदर प्रत्येक आइटम स्वयं एक array है। यह संरचना अक्सर तालिका डेटा, मैट्रिक्स, या निर्देशांक सेट का प्रतिनिधित्व करने के लिए उपयोग की जाती है, जहाँ प्रत्येक आंतरिक array संबंधित मानों के समूह को रखता है।

उदाहरण: मैट्रिक्स (2D ग्रिड)

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

उदाहरण: निर्देशांक

{
  "coordinates": [
    [35.6895, 139.6917],     // Tokyo
    [34.0522, -118.2437],    // Los Angeles
    [51.5074, -0.1278]       // London
  ]
}

प्रसिद्ध भाषाओं में JSON arrays को कैसे प्रबंधित करें?

एक बार जब आप JSON स्ट्रिंग को एक मूल डेटा संरचना में पार्स कर लेते हैं, तो आप आसानी से लूप, फिल्टर, मैप, या संशोधित कर सकते हैं arrays को भाषा के अंतर्निहित उपकरणों का उपयोग करके।

नीचे कुछ सबसे लोकप्रिय भाषाओं में उदाहरण दिए गए हैं:

1. JavaScript/TypeScript में JSON Arrays को प्रबंधित करें

JavaScript और TypeScript में JSON arrays का व्यापक रूप से उपयोग किया जाता है ताकि संरचित डेटा को संभाला जा सके — विशेष रूप से जब API प्रतिक्रियाओं, स्थानीय संग्रहण, डेटाबेस, या गतिशील UI रेंडरिंग के साथ काम कर रहे हों। उन्हें प्रभावी ढंग से प्रबंधित करना समझना साफ, कुशल कोड लिखने की कुंजी है।

यहाँ कुछ सामान्य ऑपरेशन हैं जिनकी आपको अक्सर JSON arrays के साथ काम करते समय आवश्यकता होगी:

// Sample JSON array of objects
const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false },
  { name: "Carol", active: true }
];

// 1. Loop through the array
users.forEach(user => {
  console.log("User name:", user.name);
});

// 2. Filter items
const activeUsers = users.filter(user => user.active);
console.log("Active users:", activeUsers);

// 3. Sort by name
const sortedUsers = [...users].sort((a, b) => a.name.localeCompare(b.name));
console.log("Sorted users:", sortedUsers);

// 4. Add a new item
users.push({ name: "Dave", active: true });
console.log("After adding Dave:", users);

// 5. Remove an item by index (e.g., remove second user)
users.splice(1, 1);
console.log("After removing second user:", users);

// 6. Find a user by name
const foundUser = users.find(user => user.name === "Alice");
console.log("Found user:", foundUser);

// 7. Update an object in the array (e.g., set Bob to active if he exists)
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("Updated users:", updatedUsers);

// 8. Convert array to JSON string
const jsonString = JSON.stringify(users);
console.log("JSON string:", jsonString);

// 9. Parse JSON string back to array
const parsedUsers = JSON.parse(jsonString);
console.log("Parsed users:", parsedUsers);

2. Python में JSON Arrays को प्रबंधित करें

Python में, JSON arrays को आमतौर पर सूचियों के रूप में और JSON वस्तुओं को शब्दकोशों के रूप में दर्शाया जाता है। Python का अंतर्निहित json मॉड्यूल JSON डेटा के साथ काम करना आसान बनाता है — चाहे आप API प्रतिक्रियाओं का उपभोग कर रहे हों, कॉन्फ़िगरेशन फ़ाइलें पढ़ रहे हों, या निर्यात के लिए संरचित डेटा तैयार कर रहे हों।

शब्दकोशों की सूचियों (यानी, JSON वस्तुओं के arrays) का उपयोग करना Python में डेटा को संभालने के लिए एक सामान्य पैटर्न है। यह संरचना लचीली और शक्तिशाली है, जिससे आप फ़िल्टरिंग, सॉर्टिंग, अपडेटिंग, और सीरियलाइजिंग जैसी ऑपरेशनों को आसानी से कर सकते हैं, जैसे कि सूची समावेश, sorted(), और शब्दकोश अनपैकिंग जैसी मूल Python विशेषताओं के साथ।

import json

# Sample JSON array of objects (Python list of dicts)
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. Loop through the array
for user in users:
    print("User name:", user["name"])

# 2. Filter items
active_users = [user for user in users if user["active"]]
print("Active users:", active_users)

# 3. Sort by name
sorted_users = sorted(users, key=lambda user: user["name"])
print("Sorted users:", sorted_users)

# 4. Add a new item
users.append({ "name": "Dave", "active": True })
print("After adding Dave:", users)

# 5. Remove an item by index (e.g., remove second user)
users.pop(1)
print("After removing second user:", users)

# 6. Find a user by name
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("Found user:", found_user)

# 7. Update an object in the array (e.g., set Bob to active if he exists)
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("Updated users:", updated_users)

# 8. Convert array to JSON string
json_string = json.dumps(users)
print("JSON string:", json_string)

# 9. Parse JSON string back to array
parsed_users = json.loads(json_string)
print("Parsed users:", parsed_users)

3. Java में JSON Arrays को प्रबंधित करें

Java में, JSON arrays को आमतौर पर List<Map<String, Object>> का उपयोग करके दर्शाया जाता है जब Jackson, Gson, या org.json जैसी लाइब्रेरी के साथ काम कर रहे हों। ये लाइब्रेरी आपको JSON डेटा को आसानी से पार्स, उत्पन्न और प्रबंधित करने की अनुमति देती हैं।

Java में JSON arrays को प्रबंधित करना 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();

        // Sample JSON string
        String json = "[{\"name\":\"Alice\",\"active\":true},{\"name\":\"Bob\",\"active\":false},{\"name\":\"Carol\",\"active\":true}]";

        // 1. Parse JSON string into List of Map
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("Original users: " + users);

        // 2. Loop through array
        for (Map<String, Object> user : users) {
            System.out.println("User name: " + user.get("name"));
        }

        // 3. Filter active users
        List<Map<String, Object>> activeUsers = users.stream()
                .filter(user -> Boolean.TRUE.equals(user.get("active")))
                .collect(Collectors.toList());
        System.out.println("Active users: " + activeUsers);

        // 4. Sort by name
        users.sort(Comparator.comparing(user -> (String) user.get("name")));
        System.out.println("Sorted users: " + users);

        // 5. Add a new user
        Map<String, Object> newUser = new HashMap<>();
        newUser.put("name", "Dave");
        newUser.put("active", true);
        users.add(newUser);
        System.out.println("After adding Dave: " + users);

        // 6. Remove a user by index
        users.remove(1);
        System.out.println("After removing second user: " + users);

        // 7. Find a user by name
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("Found user: " + found);

        // 8. Update Bob to active (if exists)
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. Convert list back to JSON string
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("Updated JSON string: " + updatedJson);
    }
}

4. PHP में JSON Arrays को प्रबंधित करें

PHP में, JSON arrays को आमतौर पर संघटनात्मक arrays (JSON वस्तुओं के लिए) या सूचीकृत arrays (JSON सूचियों के लिए) में डिकोड किया जाता है। PHP json_decode() और json_encode() जैसी अंतर्निहित फ़ंक्शंस प्रदान करता है जो JSON डेटा को पार्स और सीरियलाइज करना आसान बनाते हैं, जिससे JSON संरचनाओं को सीधे प्रबंधित करना आसान हो जाता है।

वस्तुओं के arrays (यानी, संघटनात्मक arrays का JSON array) के साथ काम करना API प्रतिक्रियाओं, कॉन्फ़िगरेशन फ़ाइलों, या AJAX कॉल को संभालते समय एक सामान्य पैटर्न है। PHP की लचीली array संरचना फ़िल्टरिंग, सॉर्टिंग, अपडेटिंग, और JSON arrays को सीरियलाइज करने जैसी ऑपरेशनों को करना बहुत सुविधाजनक बनाती है।

<?php

// Sample JSON string
$json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]';

// 1. Decode JSON string to PHP array
$users = json_decode($json, true);
echo "Original users:\n";
print_r($users);

// 2. Loop through the array
foreach ($users as $user) {
    echo "User name: " . $user['name'] . "\n";
}

// 3. Filter active users
$activeUsers = array_filter($users, function ($user) {
    return $user['active'] === true;
});
echo "Active users:\n";
print_r($activeUsers);

// 4. Sort users by name
usort($users, function ($a, $b) {
    return strcmp($a['name'], $b['name']);
});
echo "Sorted users:\n";
print_r($users);

// 5. Add a new user
$users[] = ["name" => "Dave", "active" => true];
echo "After adding Dave:\n";
print_r($users);

// 6. Remove a user by index (e.g., remove second user)
array_splice($users, 1, 1);
echo "After removing second user:\n";
print_r($users);

// 7. Find a user by name
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "Found user:\n";
print_r($foundUser);

// 8. Update Bob to active if exists
foreach ($users as &$user) {
    if ($user['name'] === 'Bob') {
        $user['active'] = true;
    }
}
unset($user); // break reference

// 9. Encode back to JSON
$updatedJson = json_encode($users, JSON_PRETTY_PRINT);
echo "Updated JSON:\n";
echo $updatedJson;

5. Ruby में JSON Arrays को प्रबंधित करें

Ruby में, JSON arrays को आमतौर पर अंतर्निहित json लाइब्रेरी का उपयोग करके हैश के arrays में पार्स किया जाता है। यह संरचना API प्रतिक्रियाओं, कॉन्फ़िगरेशन फ़ाइलों, और किसी भी संरचित डेटा विनिमय के साथ काम करने के लिए आदर्श है। Ruby की अभिव्यक्तिपूर्ण सिंटैक्स और enumerable विधियाँ (each, select, sort_by, map, आदि) JSON arrays को प्रबंधित करना बहुत सुविधाजनक बनाती हैं।

require 'json'

# Sample JSON string
json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]'

# 1. Parse JSON string into Ruby array of hashes
users = JSON.parse(json)
puts "Original users:"
puts users

# 2. Loop through the array
users.each do |user|
  puts "User name: #{user['name']}"
end

# 3. Filter active users
active_users = users.select { |user| user['active'] }
puts "Active users:"
puts active_users

# 4. Sort users by name
sorted_users = users.sort_by { |user| user['name'] }
puts "Sorted users:"
puts sorted_users

# 5. Add a new user
users << { 'name' => 'Dave', 'active' => true }
puts "After adding Dave:"
puts users

# 6. Remove a user by index (e.g., remove second user)
users.delete_at(1)
puts "After removing second user:"
puts users

# 7. Find a user by name
found_user = users.find { |user| user['name'] == 'Alice' }
puts "Found user:"
puts found_user

# 8. Update Bob to active (if exists)
users.map! do |user|
  user['name'] == 'Bob' ? user.merge('active' => true) : user
end

# 9. Convert back to JSON string
updated_json = JSON.pretty_generate(users)
puts "Updated JSON string:"
puts updated_json

6. Golang में JSON Arrays को प्रबंधित करें

Go में, JSON arrays को आमतौर पर structs के slices या []map[string]interface{} के लिए डिकोड किया जाता है। encoding/json पैकेज JSON को एन्कोड/डिकोड करने के लिए शक्तिशाली और लचीले उपकरण प्रदान करता है। REST APIs, कॉन्फ़िगरेशन फ़ाइलों, या डेटा रूपांतरण के साथ काम करते समय JSON प्रबंधन Go में सामान्य है।

Go की सख्त टाइपिंग और प्रदर्शन इसे मजबूत JSON हैंडलिंग के लिए आदर्श बनाते हैं, विशेष रूप से संरचित डेटा के लिए कस्टम प्रकारों को परिभाषित करते समय। नीचे एक संपूर्ण उदाहरण है जो Go में JSON arrays को प्रबंधित करने का प्रदर्शन करता है, जिसमें पार्सिंग, लूपिंग, फ़िल्टरिंग, सॉर्टिंग, अपडेटिंग, और JSON में वापस परिवर्तित करना शामिल है।

package main

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

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

func main() {
	// Sample JSON array
	jsonStr := `[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]`

	// 1. Parse JSON string to slice of structs
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("Original users:", users)

	// 2. Loop through the array
	for _, user := range users {
		fmt.Println("User name:", user.Name)
	}

	// 3. Filter active users
	var activeUsers []User
	for _, user := range users {
		if user.Active {
			activeUsers = append(activeUsers, user)
		}
	}
	fmt.Println("Active users:", activeUsers)

	// 4. Sort users by name
	sort.Slice(users, func(i, j int) bool {
		return users[i].Name < users[j].Name
	})
	fmt.Println("Sorted users:", users)

	// 5. Add a new user
	users = append(users, User{Name: "Dave", Active: true})
	fmt.Println("After adding Dave:", users)

	// 6. Remove user by index (e.g., remove second user)
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("After removing second user:", users)

	// 7. Find user by name
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("Found user:", found)

	// 8. Update Bob to active if exists
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. Convert slice back to JSON
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("Updated JSON:")
	fmt.Println(string(updatedJSON))
}

1. CodeUtility: JSON Viewer/Beautifier

• लाइन नंबर के साथ ऑटो-फॉर्मेट करें।
• संक्षिप्त और सुंदर दृश्य के बीच टॉगल करें।
• बिल्ट-इन वैलिडेशन।

लिंक: https://beautifyjson.codeutility.io

2. CodeUtility: JSON से Yaml

• JSON array को YAML में परिवर्तित करें।
• array फ़ील्ड को फ़िल्टर या निकालें।

लिंक: https://json2yaml.codeutility.io

3. JSONLint: JSON Validator

• JSON को मान्य और फ़ॉर्मेट करें।
• जांचें कि क्या आपका JSON array व्याकरणिक रूप से सही है।
• ऑटो-इंडेंट और त्रुटियों को हाइलाइट करें।

लिंक: https://jsonlint.com