Wie man Arrays in JSON verwendet (Mit Beispielen im Code)

Einführung

JSON (JavaScript Object Notation) ist eines der am häufigsten verwendeten Datenformate zum Übertragen strukturierter Informationen zwischen Systemen. Zu seinen grundlegenden Bausteinen gehört das Array, das es Ihnen ermöglicht, geordnete Listen von Daten wie Strings, Zahlen, Objekten oder sogar anderen Arrays darzustellen.

Egal, ob Sie Konfigurationsdateien definieren, Daten an eine API senden oder Serverantworten verarbeiten, das Verständnis, wie man Arrays in JSON verwendet, ist unerlässlich. Dieser Leitfaden behandelt, wie Arrays funktionieren, wie man sie definiert, in Code darauf zugreift und komplexere Fälle wie Arrays von Objekten behandelt.

Was ist ein Array in JSON?

Ein JSON-Array ist eine geordnete Liste, die in eckige Klammern [] eingeschlossen ist. Es kann jede Kombination von Werten enthalten, einschließlich:

• Strings
• Zahlen
• Booleans
• Objekte
• Andere Arrays
• null

Beispiel: Array von Strings

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

JSON-Array von Objekten

Eines der mächtigsten Muster in JSON ist das Array von Objekten. Dies wird verwendet, um Sammlungen strukturierter Daten darzustellen – wie Listen von Benutzern, Produkten oder Bestellungen.

Beispiel: Array von Objekten

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

JSON-Array von Arrays

Ein JSON-Array von Arrays ist eine geschachtelte Datenstruktur, bei der jedes Element im äußeren Array selbst ein Array ist. Diese Struktur wird häufig verwendet, um tabellarische Daten, Matrizen oder Koordinatensätze darzustellen, wobei jedes innere Array eine verwandte Gruppe von Werten enthält.

Beispiel: Matrix (2D-Gitter)

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

Beispiel: Koordinaten

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

Wie man JSON-Arrays in beliebten Sprachen manipuliert?

Sobald Sie einen JSON-String in eine native Datenstruktur geparst haben, können Sie Arrays ganz einfach durchlaufen, filtern, abbilden oder modifizieren mit den integrierten Werkzeugen der Sprache.

Im Folgenden finden Sie Beispiele in einigen der beliebtesten Sprachen:

1. JSON-Arrays in JavaScript/TypeScript manipulieren

JSON-Arrays werden in JavaScript und TypeScript häufig verwendet, um strukturierte Daten zu verarbeiten – insbesondere bei der Arbeit mit API-Antworten, lokalem Speicher, Datenbanken oder dynamischem UI-Rendering. Zu verstehen, wie man sie effektiv manipuliert, ist der Schlüssel zum Schreiben von sauberem, effizientem Code.

Hier sind einige häufige Operationen, die Sie oft benötigen, wenn Sie mit JSON-Arrays arbeiten:

// Beispiel-JSON-Array von Objekten
const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false },
  { name: "Carol", active: true }
];

// 1. Durch das Array iterieren
users.forEach(user => {
  console.log("Benutzername:", user.name);
});

// 2. Elemente filtern
const activeUsers = users.filter(user => user.active);
console.log("Aktive Benutzer:", activeUsers);

// 3. Nach Name sortieren
const sortedUsers = [...users].sort((a, b) => a.name.localeCompare(b.name));
console.log("Sortierte Benutzer:", sortedUsers);

// 4. Ein neues Element hinzufügen
users.push({ name: "Dave", active: true });
console.log("Nach dem Hinzufügen von Dave:", users);

// 5. Ein Element nach Index entfernen (z.B. zweiten Benutzer entfernen)
users.splice(1, 1);
console.log("Nach dem Entfernen des zweiten Benutzers:", users);

// 6. Einen Benutzer nach Namen finden
const foundUser = users.find(user => user.name === "Alice");
console.log("Gefundener Benutzer:", foundUser);

// 7. Ein Objekt im Array aktualisieren (z.B. Bob aktiv setzen, wenn er existiert)
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("Aktualisierte Benutzer:", updatedUsers);

// 8. Array in JSON-String umwandeln
const jsonString = JSON.stringify(users);
console.log("JSON-String:", jsonString);

// 9. JSON-String zurück in Array parsen
const parsedUsers = JSON.parse(jsonString);
console.log("Geparste Benutzer:", parsedUsers);

2. JSON-Arrays in Python manipulieren

In Python werden JSON-Arrays typischerweise als Listen und JSON-Objekte als Dictionaries dargestellt. Das integrierte json-Modul von Python erleichtert die Arbeit mit JSON-Daten – egal, ob Sie API-Antworten konsumieren, Konfigurationsdateien lesen oder strukturierte Daten für den Export vorbereiten.

Die Verwendung von Listen von Dictionaries (d.h. JSON-Arrays von Objekten) ist ein gängiges Muster, wenn Sie Daten in Python verarbeiten. Diese Struktur ist sowohl flexibel als auch leistungsstark und ermöglicht es Ihnen, Operationen wie Filtern, Sortieren, Aktualisieren und Serialisieren ganz einfach mit nativen Python-Funktionen wie List Comprehensions, sorted() und Dictionary Unpacking durchzuführen.

import json

# Beispiel-JSON-Array von Objekten (Python-Liste von Dictionaries)
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. Durch das Array iterieren
for user in users:
    print("Benutzername:", user["name"])

# 2. Elemente filtern
active_users = [user for user in users if user["active"]]
print("Aktive Benutzer:", active_users)

# 3. Nach Name sortieren
sorted_users = sorted(users, key=lambda user: user["name"])
print("Sortierte Benutzer:", sorted_users)

# 4. Ein neues Element hinzufügen
users.append({ "name": "Dave", "active": True })
print("Nach dem Hinzufügen von Dave:", users)

# 5. Ein Element nach Index entfernen (z.B. zweiten Benutzer entfernen)
users.pop(1)
print("Nach dem Entfernen des zweiten Benutzers:", users)

# 6. Einen Benutzer nach Namen finden
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("Gefundener Benutzer:", found_user)

# 7. Ein Objekt im Array aktualisieren (z.B. Bob aktiv setzen, wenn er existiert)
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("Aktualisierte Benutzer:", updated_users)

# 8. Array in JSON-String umwandeln
json_string = json.dumps(users)
print("JSON-String:", json_string)

# 9. JSON-String zurück in Array parsen
parsed_users = json.loads(json_string)
print("Geparste Benutzer:", parsed_users)

3. JSON-Arrays in Java manipulieren

In Java werden JSON-Arrays häufig mit List<Map<String, Object>> dargestellt, wenn Sie mit Bibliotheken wie Jackson, Gson oder org.json arbeiten. Diese Bibliotheken ermöglichen es Ihnen, JSON-Daten mühelos zu parsen, zu generieren und zu manipulieren.

Die Manipulation von JSON-Arrays in Java ist entscheidend, wenn Sie mit REST-API-Antworten, Datenspeicherung oder Konfigurationsdateien arbeiten. Da Java eine statisch typisierte Sprache ist, müssen Sie JSON-Daten häufig auf POJOs (Plain Old Java Objects) abbilden oder flexible Typen wie List und Map verwenden, wenn die Struktur dynamisch ist.

Beispiel (Verwendung von 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();

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

        // 1. JSON-String in Liste von Map parsen
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("Ursprüngliche Benutzer: " + users);

        // 2. Durch das Array iterieren
        for (Map<String, Object> user : users) {
            System.out.println("Benutzername: " + user.get("name"));
        }

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

        // 4. Nach Name sortieren
        users.sort(Comparator.comparing(user -> (String) user.get("name")));
        System.out.println("Sortierte Benutzer: " + users);

        // 5. Neuen Benutzer hinzufügen
        Map<String, Object> newUser = new HashMap<>();
        newUser.put("name", "Dave");
        newUser.put("active", true);
        users.add(newUser);
        System.out.println("Nach dem Hinzufügen von Dave: " + users);

        // 6. Benutzer nach Index entfernen
        users.remove(1);
        System.out.println("Nach dem Entfernen des zweiten Benutzers: " + users);

        // 7. Benutzer nach Namen finden
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("Gefundener Benutzer: " + found);

        // 8. Bob aktiv setzen (wenn er existiert)
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. Liste zurück in JSON-String umwandeln
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("Aktualisierter JSON-String: " + updatedJson);
    }
}

4. JSON-Arrays in PHP manipulieren

In PHP werden JSON-Arrays typischerweise in assoziative Arrays (für JSON-Objekte) oder indizierte Arrays (für JSON-Listen) dekodiert. PHP bietet integrierte Funktionen wie json_decode() und json_encode(), um JSON-Daten zu parsen und zu serialisieren, was die Manipulation von JSON-Strukturen direkt erleichtert.

Die Arbeit mit Arrays von Objekten (d.h. ein JSON-Array von assoziativen Arrays) ist ein gängiges Muster, wenn Sie API-Antworten, Konfigurationsdateien oder AJAX-Aufrufe verarbeiten. Die flexible Array-Struktur von PHP macht es sehr bequem, Operationen wie Filtern, Sortieren, Aktualisieren und Serialisieren von JSON-Arrays durchzuführen.

<?php

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

// 1. JSON-String in PHP-Array dekodieren
$users = json_decode($json, true);
echo "Ursprüngliche Benutzer:\n";
print_r($users);

// 2. Durch das Array iterieren
foreach ($users as $user) {
    echo "Benutzername: " . $user['name'] . "\n";
}

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

// 4. Benutzer nach Name sortieren
usort($users, function ($a, $b) {
    return strcmp($a['name'], $b['name']);
});
echo "Sortierte Benutzer:\n";
print_r($users);

// 5. Neuen Benutzer hinzufügen
$users[] = ["name" => "Dave", "active" => true];
echo "Nach dem Hinzufügen von Dave:\n";
print_r($users);

// 6. Benutzer nach Index entfernen (z.B. zweiten Benutzer entfernen)
array_splice($users, 1, 1);
echo "Nach dem Entfernen des zweiten Benutzers:\n";
print_r($users);

// 7. Benutzer nach Namen finden
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "Gefundener Benutzer:\n";
print_r($foundUser);

// 8. Bob aktiv setzen, falls vorhanden
foreach ($users as &$user) {
    if ($user['name'] === 'Bob') {
        $user['active'] = true;
    }
}
unset($user); // Referenz aufheben

// 9. Zurück zu JSON kodieren
$updatedJson = json_encode($users, JSON_PRETTY_PRINT);
echo "Aktualisiertes JSON:\n";
echo $updatedJson;

5. JSON-Arrays in Ruby manipulieren

In Ruby werden JSON-Arrays typischerweise in Arrays von Hashes mit der integrierten json-Bibliothek geparst. Diese Struktur ist ideal für die Arbeit mit API-Antworten, Konfigurationsdateien und jedem strukturierten Datenaustausch. Rubys ausdrucksvolle Syntax und enumerable Methoden (each, select, sort_by, map usw.) machen es sehr bequem, JSON-Arrays zu manipulieren.

require 'json'

# Beispiel-JSON-String
json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]'

# 1. JSON-String in Ruby-Array von Hashes parsen
users = JSON.parse(json)
puts "Ursprüngliche Benutzer:"
puts users

# 2. Durch das Array iterieren
users.each do |user|
  puts "Benutzername: #{user['name']}"
end

# 3. Aktive Benutzer filtern
active_users = users.select { |user| user['active'] }
puts "Aktive Benutzer:"
puts active_users

# 4. Benutzer nach Name sortieren
sorted_users = users.sort_by { |user| user['name'] }
puts "Sortierte Benutzer:"
puts sorted_users

# 5. Neuen Benutzer hinzufügen
users << { 'name' => 'Dave', 'active' => true }
puts "Nach dem Hinzufügen von Dave:"
puts users

# 6. Benutzer nach Index entfernen (z.B. zweiten Benutzer entfernen)
users.delete_at(1)
puts "Nach dem Entfernen des zweiten Benutzers:"
puts users

# 7. Benutzer nach Namen finden
found_user = users.find { |user| user['name'] == 'Alice' }
puts "Gefundener Benutzer:"
puts found_user

# 8. Bob aktiv setzen (falls vorhanden)
users.map! do |user|
  user['name'] == 'Bob' ? user.merge('active' => true) : user
end

# 9. Zurück zu JSON-String konvertieren
updated_json = JSON.pretty_generate(users)
puts "Aktualisierter JSON-String:"
puts updated_json

6. JSON-Arrays in Golang manipulieren

In Go werden JSON-Arrays typischerweise in Slices von Structs oder []map[string]interface{} für dynamische Strukturen dekodiert. Das Paket encoding/json bietet leistungsstarke und flexible Werkzeuge zum Kodieren/Dekodieren von JSON. Die Manipulation von JSON ist in Go häufig, wenn es um REST-APIs, Konfigurationsdateien oder Datenumwandlungen geht.

Gos strenge Typisierung und Leistung machen es ideal für eine robuste JSON-Verarbeitung, insbesondere wenn benutzerdefinierte Typen für strukturierte Daten definiert werden. Im Folgenden finden Sie ein vollständiges Beispiel, das zeigt, wie man JSON-Arrays in Go manipuliert, einschließlich Parsen, Durchlaufen, Filtern, Sortieren, Aktualisieren und Zurückkonvertieren in JSON.

package main

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

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

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

	// 1. JSON-String in Slice von Structs parsen
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("Ursprüngliche Benutzer:", users)

	// 2. Durch das Array iterieren
	for _, user := range users {
		fmt.Println("Benutzername:", user.Name)
	}

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

	// 4. Benutzer nach Name sortieren
	sort.Slice(users, func(i, j int) bool {
		return users[i].Name < users[j].Name
	})
	fmt.Println("Sortierte Benutzer:", users)

	// 5. Neuen Benutzer hinzufügen
	users = append(users, User{Name: "Dave", Active: true})
	fmt.Println("Nach dem Hinzufügen von Dave:", users)

	// 6. Benutzer nach Index entfernen (z.B. zweiten Benutzer entfernen)
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("Nach dem Entfernen des zweiten Benutzers:", users)

	// 7. Benutzer nach Namen finden
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("Gefundener Benutzer:", found)

	// 8. Bob aktiv setzen, falls vorhanden
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. Slice zurück in JSON konvertieren
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("Aktualisiertes JSON:")
	fmt.Println(string(updatedJSON))
}

Nützliche Online-Tools für die Arbeit mit JSON-Arrays

1. CodeUtility: JSON Viewer/Beautifier

• Automatische Formatierung mit Zeilennummern.
• Wechseln zwischen kompakter und schöner Ansicht.
• Integrierte Validierung.

Link: https://beautifyjson.codeutility.io

2. CodeUtility: JSON nach YAML

• JSON-Array in YAML konvertieren.
• Felder im Array filtern oder extrahieren.

Link: https://json2yaml.codeutility.io

3. JSONLint: JSON-Validator

• JSON validieren und formatieren.
• Überprüft, ob Ihr JSON-Array syntaktisch korrekt ist.
• Automatisches Einrücken und Hervorheben von Fehlern.

Link: https://jsonlint.com