Comment utiliser les tableaux en JSON (Avec des exemples de code)

Introduction

JSON (JavaScript Object Notation) est l'un des formats de données les plus utilisés pour transmettre des informations structurées entre les systèmes. Parmi ses éléments de base, on trouve le tableau, qui vous permet de représenter des listes ordonnées de données telles que des chaînes, des nombres, des objets ou même d'autres tableaux.

Que vous définissiez des fichiers de configuration, envoyiez des données à une API ou traitiez des réponses de serveur, comprendre comment utiliser les tableaux en JSON est essentiel. Ce guide couvre le fonctionnement des tableaux, comment les définir, y accéder dans le code et gérer des cas plus complexes comme les tableaux d'objets.

Qu'est-ce qu'un tableau en JSON ?

Un tableau JSON est une liste ordonnée enfermée dans des crochets []. Il peut contenir n'importe quelle combinaison de valeurs, y compris :

• Chaînes
• Nombres
• Booléens
• Objets
• Autres tableaux
• null

Exemple : Tableau de chaînes

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

Tableau JSON d'objets

Un des modèles les plus puissants en JSON est le tableau d'objets. Cela est utilisé pour représenter des collections de données structurées, comme des listes d'utilisateurs, de produits ou de commandes.

Exemple : Tableau d'objets

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

Tableau JSON de tableaux

Un tableau JSON de tableaux est une structure de données imbriquée où chaque élément à l'intérieur du tableau extérieur est lui-même un tableau. Cette structure est souvent utilisée pour représenter des données tabulaires, des matrices ou des ensembles de coordonnées, où chaque tableau interne contient un groupe de valeurs liées.

Exemple : Matrice (Grille 2D)

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

Exemple : Coordonnées

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

Comment manipuler les tableaux JSON dans les langages populaires ?

Une fois que vous avez analysé une chaîne JSON en une structure de données native, vous pouvez facilement boucler, filtrer, mapper ou modifier des tableaux en utilisant les outils intégrés du langage.

Voici quelques exemples dans certains des langages les plus populaires :

1. Manipuler les tableaux JSON en JavaScript/TypeScript

Les tableaux JSON sont largement utilisés en JavaScript et TypeScript pour gérer des données structurées, notamment lors de l'utilisation de réponses d'API, de stockage local, de bases de données ou de rendu dynamique d'interface utilisateur. Comprendre comment les manipuler efficacement est essentiel pour écrire un code propre et efficace.

Voici quelques opérations courantes que vous aurez souvent besoin d'effectuer lors de la manipulation de tableaux JSON :

// Exemple de tableau JSON d'objets
const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false },
  { name: "Carol", active: true }
];

// 1. Boucle à travers le tableau
users.forEach(user => {
  console.log("Nom de l'utilisateur :", user.name);
});

// 2. Filtrer les éléments
const activeUsers = users.filter(user => user.active);
console.log("Utilisateurs actifs :", activeUsers);

// 3. Trier par nom
const sortedUsers = [...users].sort((a, b) => a.name.localeCompare(b.name));
console.log("Utilisateurs triés :", sortedUsers);

// 4. Ajouter un nouvel élément
users.push({ name: "Dave", active: true });
console.log("Après avoir ajouté Dave :", users);

// 5. Supprimer un élément par index (par exemple, supprimer le deuxième utilisateur)
users.splice(1, 1);
console.log("Après avoir supprimé le deuxième utilisateur :", users);

// 6. Trouver un utilisateur par nom
const foundUser = users.find(user => user.name === "Alice");
console.log("Utilisateur trouvé :", foundUser);

// 7. Mettre à jour un objet dans le tableau (par exemple, définir Bob comme actif s'il existe)
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("Utilisateurs mis à jour :", updatedUsers);

// 8. Convertir le tableau en chaîne JSON
const jsonString = JSON.stringify(users);
console.log("Chaîne JSON :", jsonString);

// 9. Analyser la chaîne JSON en tableau
const parsedUsers = JSON.parse(jsonString);
console.log("Utilisateurs analysés :", parsedUsers);

2. Manipuler les tableaux JSON en Python

En Python, les tableaux JSON sont généralement représentés sous forme de listes, et les objets JSON sous forme de dictionnaires. Le module json intégré de Python facilite le travail avec les données JSON, que vous consommiez des réponses d'API, lisiez des fichiers de configuration ou prépariez des données structurées pour l'exportation.

Utiliser des listes de dictionnaires (c'est-à-dire des tableaux JSON d'objets) est un modèle courant lors de la manipulation de données en Python. Cette structure est à la fois flexible et puissante, vous permettant d'effectuer des opérations comme le filtrage, le tri, la mise à jour et la sérialisation facilement avec des fonctionnalités natives de Python telles que les compréhensions de liste, sorted() et le déballage de dictionnaires.

import json

# Exemple de tableau JSON d'objets (liste Python de dicts)
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. Boucle à travers le tableau
for user in users:
    print("Nom de l'utilisateur :", user["name"])

# 2. Filtrer les éléments
active_users = [user for user in users if user["active"]]
print("Utilisateurs actifs :", active_users)

# 3. Trier par nom
sorted_users = sorted(users, key=lambda user: user["name"])
print("Utilisateurs triés :", sorted_users)

# 4. Ajouter un nouvel élément
users.append({ "name": "Dave", "active": True })
print("Après avoir ajouté Dave :", users)

# 5. Supprimer un élément par index (par exemple, supprimer le deuxième utilisateur)
users.pop(1)
print("Après avoir supprimé le deuxième utilisateur :", users)

# 6. Trouver un utilisateur par nom
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("Utilisateur trouvé :", found_user)

# 7. Mettre à jour un objet dans le tableau (par exemple, définir Bob comme actif s'il existe)
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("Utilisateurs mis à jour :", updated_users)

# 8. Convertir le tableau en chaîne JSON
json_string = json.dumps(users)
print("Chaîne JSON :", json_string)

# 9. Analyser la chaîne JSON en tableau
parsed_users = json.loads(json_string)
print("Utilisateurs analysés :", parsed_users)

3. Manipuler les tableaux JSON en Java

En Java, les tableaux JSON sont couramment représentés par List<Map<String, Object>> lors de l'utilisation de bibliothèques comme Jackson, Gson ou org.json. Ces bibliothèques vous permettent d'analyser, de générer et de manipuler des données JSON facilement.

Manipuler des tableaux JSON en Java est essentiel lors du traitement des réponses d'API REST, du stockage de données ou des fichiers de configuration. Étant donné que Java est un langage à typage statique, vous devrez souvent mapper les données JSON à des POJOs (Plain Old Java Objects), ou utiliser des types flexibles comme List et Map lorsque la structure est dynamique.

Exemple (Utilisation de 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();

        // Exemple de chaîne JSON
        String json = "[{\"name\":\"Alice\",\"active\":true},{\"name\":\"Bob\",\"active\":false},{\"name\":\"Carol\",\"active\":true}]";

        // 1. Analyser la chaîne JSON en liste de Map
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("Utilisateurs originaux : " + users);

        // 2. Boucle à travers le tableau
        for (Map<String, Object> user : users) {
            System.out.println("Nom de l'utilisateur : " + user.get("name"));
        }

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

        // 4. Trier par nom
        users.sort(Comparator.comparing(user -> (String) user.get("name")));
        System.out.println("Utilisateurs triés : " + users);

        // 5. Ajouter un nouvel utilisateur
        Map<String, Object> newUser = new HashMap<>();
        newUser.put("name", "Dave");
        newUser.put("active", true);
        users.add(newUser);
        System.out.println("Après avoir ajouté Dave : " + users);

        // 6. Supprimer un utilisateur par index
        users.remove(1);
        System.out.println("Après avoir supprimé le deuxième utilisateur : " + users);

        // 7. Trouver un utilisateur par nom
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("Utilisateur trouvé : " + found);

        // 8. Mettre à jour Bob pour qu'il soit actif (s'il existe)
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. Convertir la liste en chaîne JSON
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("Chaîne JSON mise à jour : " + updatedJson);
    }
}

4. Manipuler les tableaux JSON en PHP

En PHP, les tableaux JSON sont généralement décodés en tableaux associatifs (pour les objets JSON) ou en tableaux indexés (pour les listes JSON). PHP fournit des fonctions intégrées comme json_decode() et json_encode() pour analyser et sérialiser les données JSON, ce qui facilite la manipulation des structures JSON directement.

Travailler avec des tableaux d'objets (c'est-à-dire un tableau JSON de tableaux associatifs) est un modèle courant lors de la manipulation de réponses d'API, de fichiers de configuration ou d'appels AJAX. La structure de tableau flexible de PHP rend très pratique l'exécution d'opérations telles que le filtrage, le tri, la mise à jour et la sérialisation des tableaux JSON.

<?php

// Exemple de chaîne JSON
$json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]';

// 1. Décoder la chaîne JSON en tableau PHP
$users = json_decode($json, true);
echo "Utilisateurs originaux :\n";
print_r($users);

// 2. Boucle à travers le tableau
foreach ($users as $user) {
    echo "Nom de l'utilisateur : " . $user['name'] . "\n";
}

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

// 4. Trier les utilisateurs par nom
usort($users, function ($a, $b) {
    return strcmp($a['name'], $b['name']);
});
echo "Utilisateurs triés :\n";
print_r($users);

// 5. Ajouter un nouvel utilisateur
$users[] = ["name" => "Dave", "active" => true];
echo "Après avoir ajouté Dave :\n";
print_r($users);

// 6. Supprimer un utilisateur par index (par exemple, supprimer le deuxième utilisateur)
array_splice($users, 1, 1);
echo "Après avoir supprimé le deuxième utilisateur :\n";
print_r($users);

// 7. Trouver un utilisateur par nom
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "Utilisateur trouvé :\n";
print_r($foundUser);

// 8. Mettre à jour Bob pour qu'il soit actif s'il existe
foreach ($users as &$user) {
    if ($user['name'] === 'Bob') {
        $user['active'] = true;
    }
}
unset($user); // rompre la référence

// 9. Encoder à nouveau en JSON
$updatedJson = json_encode($users, JSON_PRETTY_PRINT);
echo "JSON mis à jour :\n";
echo $updatedJson;

5. Manipuler les tableaux JSON en Ruby

En Ruby, les tableaux JSON sont généralement analysés en tableaux de hachages à l'aide de la bibliothèque json intégrée. Cette structure est idéale pour travailler avec des réponses d'API, des fichiers de configuration et tout échange de données structurées. La syntaxe expressive de Ruby et ses méthodes énumérables (each, select, sort_by, map, etc.) rendent très pratique la manipulation des tableaux JSON.

require 'json'

# Exemple de chaîne JSON
json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]'

# 1. Analyser la chaîne JSON en tableau Ruby de hachages
users = JSON.parse(json)
puts "Utilisateurs originaux :"
puts users

# 2. Boucle à travers le tableau
users.each do |user|
  puts "Nom de l'utilisateur : #{user['name']}"
end

# 3. Filtrer les utilisateurs actifs
active_users = users.select { |user| user['active'] }
puts "Utilisateurs actifs :"
puts active_users

# 4. Trier les utilisateurs par nom
sorted_users = users.sort_by { |user| user['name'] }
puts "Utilisateurs triés :"
puts sorted_users

# 5. Ajouter un nouvel utilisateur
users << { 'name' => 'Dave', 'active' => true }
puts "Après avoir ajouté Dave :"
puts users

# 6. Supprimer un utilisateur par index (par exemple, supprimer le deuxième utilisateur)
users.delete_at(1)
puts "Après avoir supprimé le deuxième utilisateur :"
puts users

# 7. Trouver un utilisateur par nom
found_user = users.find { |user| user['name'] == 'Alice' }
puts "Utilisateur trouvé :"
puts found_user

# 8. Mettre à jour Bob pour qu'il soit actif (s'il existe)
users.map! do |user|
  user['name'] == 'Bob' ? user.merge('active' => true) : user
end

# 9. Convertir à nouveau en chaîne JSON
updated_json = JSON.pretty_generate(users)
puts "Chaîne JSON mise à jour :"
puts updated_json

6. Manipuler les tableaux JSON en Golang

En Go, les tableaux JSON sont généralement décodés en tranches de structures ou []map[string]interface{} pour des structures dynamiques. Le package encoding/json fournit des outils puissants et flexibles pour encoder/décoder JSON. La manipulation de JSON est courante en Go lors du traitement des API REST, des fichiers de configuration ou de la transformation de données.

Le typage strict et la performance de Go en font un choix idéal pour un traitement robuste de JSON, notamment lors de la définition de types personnalisés pour des données structurées. Voici un exemple complet démontrant comment manipuler des tableaux JSON en Go, couvrant l'analyse, la boucle, le filtrage, le tri, la mise à jour et la conversion de nouveau en JSON.

package main

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

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

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

	// 1. Analyser la chaîne JSON en tranche de structures
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("Utilisateurs originaux :", users)

	// 2. Boucle à travers le tableau
	for _, user := range users {
		fmt.Println("Nom de l'utilisateur :", user.Name)
	}

	// 3. Filtrer les utilisateurs actifs
	var activeUsers []User
	for _, user := range users {
		if user.Active {
			activeUsers = append(activeUsers, user)
		}
	}
	fmt.Println("Utilisateurs actifs :", activeUsers)

	// 4. Trier les utilisateurs par nom
	sort.Slice(users, func(i, j int) bool {
		return users[i].Name < users[j].Name
	})
	fmt.Println("Utilisateurs triés :", users)

	// 5. Ajouter un nouvel utilisateur
	users = append(users, User{Name: "Dave", Active: true})
	fmt.Println("Après avoir ajouté Dave :", users)

	// 6. Supprimer un utilisateur par index (par exemple, supprimer le deuxième utilisateur)
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("Après avoir supprimé le deuxième utilisateur :", users)

	// 7. Trouver un utilisateur par nom
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("Utilisateur trouvé :", found)

	// 8. Mettre à jour Bob pour qu'il soit actif s'il existe
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. Convertir la tranche en JSON
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON mis à jour :")
	fmt.Println(string(updatedJSON))
}

Outils en ligne utiles pour travailler avec des tableaux JSON

1. CodeUtility : Visualiseur/Beautificateur JSON

• Formatage automatique avec numéros de ligne.
• Basculer entre la vue compacte et la vue jolie.
• Validation intégrée.

Lien : https://beautifyjson.codeutility.io

2. CodeUtility : JSON vers YAML

• Convertir un tableau JSON en YAML.
• Filtrer ou extraire des champs de tableau.

Lien : https://json2yaml.codeutility.io

3. JSONLint : Validateur JSON

• Valider et formater JSON.
• Vérifie si votre tableau JSON est syntaxiquement correct.
• Indentation automatique et mise en évidence des erreurs.

Lien : https://jsonlint.com