Come usare gli Array in JSON (Con Esempi di Codice)

Introduzione

JSON (JavaScript Object Notation) è uno dei formati di dati più utilizzati per trasmettere informazioni strutturate tra sistemi. Tra i suoi elementi fondamentali c'è l'array, che consente di rappresentare elenchi ordinati di dati come stringhe, numeri, oggetti o anche altri array.

Che tu stia definendo file di configurazione, inviando dati a un'API o elaborando risposte del server, comprendere come utilizzare gli array in JSON è fondamentale. Questa guida copre come funzionano gli array, come definirli, accedervi nel codice e gestire casi più complessi come gli array di oggetti.

Che cos'è un Array in JSON?

Un array JSON è un elenco ordinato racchiuso tra parentesi quadre []. Può contenere qualsiasi combinazione di valori, inclusi:

• Stringhe
• Numeri
• Booleani
• Oggetti
• Altri array
• null

Esempio: Array di stringhe

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

JSON Array di Oggetti

Uno dei modelli più potenti in JSON è l'array di oggetti. Questo viene utilizzato per rappresentare collezioni di dati strutturati, come elenchi di utenti, prodotti o ordini.

Esempio: Array di Oggetti

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

JSON Array di Arrays

Un JSON array di arrays è una struttura dati annidata in cui ogni elemento all'interno dell'array esterno è a sua volta un array. Questa struttura è spesso utilizzata per rappresentare dati tabulari, matrici o insiemi di coordinate, dove ogni array interno contiene un gruppo di valori correlati.

Esempio: Matrice (Griglia 2D)

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

Esempio: Coordinate

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

Come Manipolare gli Array JSON nei Linguaggi Popolari?

Una volta che hai analizzato una stringa JSON in una struttura dati nativa, puoi facilmente iterare, filtrare, mappare o modificare gli array utilizzando gli strumenti integrati del linguaggio.

Di seguito sono riportati esempi in alcuni dei linguaggi più popolari:

1. Manipolare gli Array JSON in JavaScript/TypeScript

Gli array JSON sono ampiamente utilizzati in JavaScript e TypeScript per gestire dati strutturati, specialmente quando si lavora con risposte API, archiviazione locale, database o rendering dinamico dell'interfaccia utente. Comprendere come manipolarli in modo efficace è fondamentale per scrivere codice pulito ed efficiente.

Ecco alcune operazioni comuni che dovrai spesso eseguire quando lavori con gli array JSON:

// Esempio di array JSON di oggetti
const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false },
  { name: "Carol", active: true }
];

// 1. Itera attraverso l'array
users.forEach(user => {
  console.log("Nome utente:", user.name);
});

// 2. Filtra gli elementi
const activeUsers = users.filter(user => user.active);
console.log("Utenti attivi:", activeUsers);

// 3. Ordina per nome
const sortedUsers = [...users].sort((a, b) => a.name.localeCompare(b.name));
console.log("Utenti ordinati:", sortedUsers);

// 4. Aggiungi un nuovo elemento
users.push({ name: "Dave", active: true });
console.log("Dopo aver aggiunto Dave:", users);

// 5. Rimuovi un elemento per indice (ad esempio, rimuovi il secondo utente)
users.splice(1, 1);
console.log("Dopo aver rimosso il secondo utente:", users);

// 6. Trova un utente per nome
const foundUser = users.find(user => user.name === "Alice");
console.log("Utente trovato:", foundUser);

// 7. Aggiorna un oggetto nell'array (ad esempio, imposta Bob come attivo se esiste)
const updatedUsers = users.map(user =>
  user.name === "Bob" ? { ...user, active: true } : user
);
console.log("Utenti aggiornati:", updatedUsers);

// 8. Converti l'array in stringa JSON
const jsonString = JSON.stringify(users);
console.log("Stringa JSON:", jsonString);

// 9. Analizza la stringa JSON di nuovo in un array
const parsedUsers = JSON.parse(jsonString);
console.log("Utenti analizzati:", parsedUsers);

2. Manipolare gli Array JSON in Python

In Python, gli array JSON sono tipicamente rappresentati come liste, e gli oggetti JSON come dizionari. Il modulo json integrato di Python rende facile lavorare con i dati JSON, sia che tu stia consumando risposte API, leggendo file di configurazione o preparando dati strutturati per l'esportazione.

Utilizzare liste di dizionari (cioè, array JSON di oggetti) è un modello comune quando si gestiscono dati in Python. Questa struttura è sia flessibile che potente, consentendo di eseguire operazioni come filtraggio, ordinamento, aggiornamento e serializzazione facilmente con funzionalità native di Python come le comprensioni di lista, sorted() e lo unpacking dei dizionari.

import json

# Esempio di array JSON di oggetti (lista Python di dizionari)
users = [
    { "name": "Alice", "active": True },
    { "name": "Bob", "active": False },
    { "name": "Carol", "active": True }
]

# 1. Itera attraverso l'array
for user in users:
    print("Nome utente:", user["name"])

# 2. Filtra gli elementi
active_users = [user for user in users if user["active"]]
print("Utenti attivi:", active_users)

# 3. Ordina per nome
sorted_users = sorted(users, key=lambda user: user["name"])
print("Utenti ordinati:", sorted_users)

# 4. Aggiungi un nuovo elemento
users.append({ "name": "Dave", "active": True })
print("Dopo aver aggiunto Dave:", users)

# 5. Rimuovi un elemento per indice (ad esempio, rimuovi il secondo utente)
users.pop(1)
print("Dopo aver rimosso il secondo utente:", users)

# 6. Trova un utente per nome
found_user = next((user for user in users if user["name"] == "Alice"), None)
print("Utente trovato:", found_user)

# 7. Aggiorna un oggetto nell'array (ad esempio, imposta Bob come attivo se esiste)
updated_users = [
    { **user, "active": True } if user["name"] == "Bob" else user
    for user in users
]
print("Utenti aggiornati:", updated_users)

# 8. Converti l'array in stringa JSON
json_string = json.dumps(users)
print("Stringa JSON:", json_string)

# 9. Analizza la stringa JSON di nuovo in un array
parsed_users = json.loads(json_string)
print("Utenti analizzati:", parsed_users)

3. Manipolare gli Array JSON in Java

In Java, gli array JSON sono comunemente rappresentati usando List<Map<String, Object>> quando si lavora con librerie come Jackson, Gson o org.json. Queste librerie ti consentono di analizzare, generare e manipolare i dati JSON con facilità.

Manipolare gli array JSON in Java è essenziale quando si tratta di risposte API REST, archiviazione dei dati o file di configurazione. Poiché Java è un linguaggio a tipizzazione statica, dovrai spesso mappare i dati JSON a POJO (Plain Old Java Objects), o utilizzare tipi flessibili come List e Map quando la struttura è dinamica.

Esempio (Usando 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();

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

        // 1. Analizza la stringa JSON in List di Map
        List<Map<String, Object>> users = mapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
        System.out.println("Utenti originali: " + users);

        // 2. Itera attraverso l'array
        for (Map<String, Object> user : users) {
            System.out.println("Nome utente: " + user.get("name"));
        }

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

        // 4. Ordina per nome
        users.sort(Comparator.comparing(user -> (String) user.get("name")));
        System.out.println("Utenti ordinati: " + users);

        // 5. Aggiungi un nuovo utente
        Map<String, Object> newUser = new HashMap<>();
        newUser.put("name", "Dave");
        newUser.put("active", true);
        users.add(newUser);
        System.out.println("Dopo aver aggiunto Dave: " + users);

        // 6. Rimuovi un utente per indice
        users.remove(1);
        System.out.println("Dopo aver rimosso il secondo utente: " + users);

        // 7. Trova un utente per nome
        Map<String, Object> found = users.stream()
                .filter(user -> "Alice".equals(user.get("name")))
                .findFirst()
                .orElse(null);
        System.out.println("Utente trovato: " + found);

        // 8. Aggiorna Bob come attivo (se esiste)
        for (Map<String, Object> user : users) {
            if ("Bob".equals(user.get("name"))) {
                user.put("active", true);
            }
        }

        // 9. Converti la lista di nuovo in stringa JSON
        String updatedJson = mapper.writeValueAsString(users);
        System.out.println("Stringa JSON aggiornata: " + updatedJson);
    }
}

4. Manipolare gli Array JSON in PHP

In PHP, gli array JSON vengono tipicamente decodificati in array associativi (per oggetti JSON) o array indicizzati (per liste JSON). PHP fornisce funzioni integrate come json_decode() e json_encode() per analizzare e serializzare i dati JSON, rendendo facile manipolare direttamente le strutture JSON.

Lavorare con array di oggetti (cioè, un array JSON di array associativi) è un modello comune quando si gestiscono risposte API, file di configurazione o chiamate AJAX. La struttura flessibile degli array di PHP rende molto conveniente eseguire operazioni come filtraggio, ordinamento, aggiornamento e serializzazione degli array JSON.

<?php

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

// 1. Decodifica la stringa JSON in array PHP
$users = json_decode($json, true);
echo "Utenti originali:\n";
print_r($users);

// 2. Itera attraverso l'array
foreach ($users as $user) {
    echo "Nome utente: " . $user['name'] . "\n";
}

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

// 4. Ordina gli utenti per nome
usort($users, function ($a, $b) {
    return strcmp($a['name'], $b['name']);
});
echo "Utenti ordinati:\n";
print_r($users);

// 5. Aggiungi un nuovo utente
$users[] = ["name" => "Dave", "active" => true];
echo "Dopo aver aggiunto Dave:\n";
print_r($users);

// 6. Rimuovi un utente per indice (ad esempio, rimuovi il secondo utente)
array_splice($users, 1, 1);
echo "Dopo aver rimosso il secondo utente:\n";
print_r($users);

// 7. Trova un utente per nome
$foundUser = null;
foreach ($users as $user) {
    if ($user['name'] === 'Alice') {
        $foundUser = $user;
        break;
    }
}
echo "Utente trovato:\n";
print_r($foundUser);

// 8. Aggiorna Bob come attivo se esiste
foreach ($users as &$user) {
    if ($user['name'] === 'Bob') {
        $user['active'] = true;
    }
}
unset($user); // interrompi riferimento

// 9. Codifica di nuovo in JSON
$updatedJson = json_encode($users, JSON_PRETTY_PRINT);
echo "JSON aggiornato:\n";
echo $updatedJson;

5. Manipolare gli Array JSON in Ruby

In Ruby, gli array JSON vengono tipicamente analizzati in array di hash utilizzando la libreria json integrata. Questa struttura è ideale per lavorare con risposte API, file di configurazione e qualsiasi scambio di dati strutturati. La sintassi espressiva di Ruby e i metodi enumerabili (each, select, sort_by, map, ecc.) rendono molto conveniente manipolare gli array JSON.

require 'json'

# Esempio di stringa JSON
json = '[{"name":"Alice","active":true},{"name":"Bob","active":false},{"name":"Carol","active":true}]'

# 1. Analizza la stringa JSON in array Ruby di hash
users = JSON.parse(json)
puts "Utenti originali:"
puts users

# 2. Itera attraverso l'array
users.each do |user|
  puts "Nome utente: #{user['name']}"
end

# 3. Filtra gli utenti attivi
active_users = users.select { |user| user['active'] }
puts "Utenti attivi:"
puts active_users

# 4. Ordina gli utenti per nome
sorted_users = users.sort_by { |user| user['name'] }
puts "Utenti ordinati:"
puts sorted_users

# 5. Aggiungi un nuovo utente
users << { 'name' => 'Dave', 'active' => true }
puts "Dopo aver aggiunto Dave:"
puts users

# 6. Rimuovi un utente per indice (ad esempio, rimuovi il secondo utente)
users.delete_at(1)
puts "Dopo aver rimosso il secondo utente:"
puts users

# 7. Trova un utente per nome
found_user = users.find { |user| user['name'] == 'Alice' }
puts "Utente trovato:"
puts found_user

# 8. Aggiorna Bob come attivo (se esiste)
users.map! do |user|
  user['name'] == 'Bob' ? user.merge('active' => true) : user
end

# 9. Converti di nuovo in stringa JSON
updated_json = JSON.pretty_generate(users)
puts "Stringa JSON aggiornata:"
puts updated_json

6. Manipolare gli Array JSON in Golang

In Go, gli array JSON vengono tipicamente decodificati in slice di struct o []map[string]interface{} per strutture dinamiche. Il pacchetto encoding/json fornisce strumenti potenti e flessibili per codificare/decodificare JSON. La manipolazione di JSON è comune in Go quando si tratta di API REST, file di configurazione o trasformazione dei dati.

La tipizzazione rigorosa e le prestazioni di Go lo rendono ideale per una gestione robusta di JSON, specialmente quando si definiscono tipi personalizzati per dati strutturati. Di seguito è riportato un esempio completo che dimostra come manipolare gli array JSON in Go, coprendo analisi, iterazione, filtraggio, ordinamento, aggiornamento e conversione di nuovo in JSON.

package main

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

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

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

	// 1. Analizza la stringa JSON in slice di struct
	var users []User
	err := json.Unmarshal([]byte(jsonStr), &users)
	if err != nil {
		panic(err)
	}
	fmt.Println("Utenti originali:", users)

	// 2. Itera attraverso l'array
	for _, user := range users {
		fmt.Println("Nome utente:", user.Name)
	}

	// 3. Filtra gli utenti attivi
	var activeUsers []User
	for _, user := range users {
		if user.Active {
			activeUsers = append(activeUsers, user)
		}
	}
	fmt.Println("Utenti attivi:", activeUsers)

	// 4. Ordina gli utenti per nome
	sort.Slice(users, func(i, j int) bool {
		return users[i].Name < users[j].Name
	})
	fmt.Println("Utenti ordinati:", users)

	// 5. Aggiungi un nuovo utente
	users = append(users, User{Name: "Dave", Active: true})
	fmt.Println("Dopo aver aggiunto Dave:", users)

	// 6. Rimuovi un utente per indice (ad esempio, rimuovi il secondo utente)
	if len(users) > 1 {
		users = append(users[:1], users[2:]...)
	}
	fmt.Println("Dopo aver rimosso il secondo utente:", users)

	// 7. Trova un utente per nome
	var found *User
	for i := range users {
		if users[i].Name == "Alice" {
			found = &users[i]
			break
		}
	}
	fmt.Println("Utente trovato:", found)

	// 8. Aggiorna Bob come attivo se esiste
	for i := range users {
		if users[i].Name == "Bob" {
			users[i].Active = true
		}
	}

	// 9. Converti slice di nuovo in JSON
	updatedJSON, err := json.MarshalIndent(users, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println("JSON aggiornato:")
	fmt.Println(string(updatedJSON))
}

Strumenti Online Utili per Lavorare con gli Array JSON

1. CodeUtility: Visualizzatore/Abbellitore JSON

• Formattazione automatica con numeri di riga.
• Attiva/disattiva tra vista compatta e bella.
• Validazione integrata.

Link: https://beautifyjson.codeutility.io

2. CodeUtility: JSON in Yaml

• Converti l'array JSON in YAML.
• Filtra o estrai i campi dell'array.

Link: https://json2yaml.codeutility.io

3. JSONLint: Validatore JSON

• Valida e formatta JSON.
• Controlla se il tuo array JSON è sintatticamente corretto.
• Indenta automaticamente e evidenzia gli errori.

Link: https://jsonlint.com