Parsing di JSON: definizione ed esempi in 7 linguaggi

Che cos’è JSON

JSON (JavaScript Object Notation) è un formato di testo per lo scambio di dati, comodo sia per la lettura da parte delle persone sia per l’elaborazione automatica. Nonostante le origini in JavaScript, il formato è diventato da tempo uno standard indipendente dal linguaggio e si usa praticamente ovunque le applicazioni abbiano bisogno di scambiarsi dati strutturati.

Esempio di base di un documento JSON:

{
  "id": 42,
  "name": "Anna",
  "is_active": true,
  "roles": ["admin", "editor"],
  "profile": {
    "city": "Roma",
    "age": 29
  }
}

Il formato si compone di pochi tipi semplici: oggetti (coppie «chiave-valore»), array, stringhe, numeri, valori booleani e null. È proprio questa semplicità la ragione della sua diffusione universale.

Che cos’è il parsing di JSON e a cosa serve

Il parsing di JSON (analisi sintattica) è il processo che converte il testo JSON in una struttura dati comprensibile a un linguaggio di programmazione concreto: un oggetto, un dizionario, un array, una lista e così via. In sostanza il parser prende una stringa di caratteri e la trasforma in oggetti vivi, con cui si può lavorare nel codice.

Il processo inverso — trasformare gli oggetti del programma di nuovo in una stringa JSON — si chiama serializzazione (o marshalling). Parsing e serializzazione vanno quasi sempre in coppia.

Il parsing serve nei compiti più tipici:

• Lavoro con le API — ricezione e invio di dati via HTTP (ne parliamo in dettaglio più sotto).
• File di configurazione — molti strumenti salvano le impostazioni in JSON (package.json, tsconfig.json e altri).
• Archiviazione e scambio di dati — log, messaggi nelle code (Kafka, RabbitMQ), documenti nei database NoSQL (MongoDB).
• Comunicazione tra servizi in un’architettura a microservizi.
• Salvataggio dello stato dell’applicazione su file o nel localStorage del browser.

Il parsing di JSON nel lavoro con le API

Lo scenario più frequente in cui uno sviluppatore incontra il parsing di JSON è l’interazione con le API. La stragrande maggioranza delle web API moderne (REST, e spesso anche altri stili) scambia dati proprio in formato JSON.

Il ciclo tipico di lavoro con un’API è questo:

1. Il client invia una richiesta HTTP a un endpoint dell’API.
2. Il server risponde con un corpo in forma di stringa JSON.
3. Il client esegue il parsing di quella stringa, la trasforma in oggetti e continua a lavorare con i dati.
4. Quando invia dati (POST, PUT), il client fa il contrario: serializza i propri oggetti in JSON.

Senza il passaggio del parsing, la risposta del server resta semplice testo, con cui non si può lavorare comodamente in modo programmatico. Per questo il parsing è un anello obbligatorio di quasi ogni integrazione con un servizio esterno.

Vedi anche: l’articolo «Estrazione di dati via API» — lì si spiega in dettaglio come sono strutturate le richieste alle API, come gestire le risposte e come lavorare con intestazioni, codici di stato, paginazione e autenticazione. Questo articolo si concentra proprio sulla fase di analisi dei dati JSON, che di quel processo è parte integrante.

Esempi di parsing di JSON in vari linguaggi

Qui sotto trovi esempi di parsing di JSON nei linguaggi più diffusi. In ogni caso si analizza la stessa stringa e poi si estrae il valore di un campo annidato.

Python

La libreria standard include il modulo json. Il metodo loads analizza una stringa; load, il contenuto di un file.

import json

data_str = '{"name": "Anna", "profile": {"city": "Roma", "age": 29}}'

# Parsing della stringa in un dizionario
data = json.loads(data_str)

print(data["name"])              # Anna
print(data["profile"]["city"])   # Roma

# Operazione inversa: serializzazione
back_to_str = json.dumps(data, ensure_ascii=False)

JavaScript

In JavaScript il parsing è integrato nel linguaggio tramite l’oggetto globale JSON. È il formato «nativo» dell’ecosistema.

const dataStr = '{"name": "Anna", "profile": {"city": "Roma", "age": 29}}';

// Parsing della stringa in un oggetto
const data = JSON.parse(dataStr);

console.log(data.name);            // Anna
console.log(data.profile.city);    // Roma

// Operazione inversa
const backToStr = JSON.stringify(data);

Con fetch, il parsing della risposta di un’API si fa in una sola riga:

const response = await fetch("https://api.example.com/users/42");
const user = await response.json(); // la risposta arriva già convertita in oggetto
console.log(user.name);

Java

La libreria standard non include un parser, quindi di solito si usano librerie esterne — ad esempio Jackson o Gson. Esempio con Jackson:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        String dataStr = "{\"name\": \"Anna\", \"profile\": {\"city\": \"Roma\"}}";

        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = mapper.readTree(dataStr);

        System.out.println(node.get("name").asText());                  // Anna
        System.out.println(node.get("profile").get("city").asText());   // Roma
    }
}

Più spesso il JSON viene convertito direttamente in una classe tipizzata (POJO):

record Profile(String city, int age) {}
record User(String name, Profile profile) {}

User user = mapper.readValue(dataStr, User.class);
System.out.println(user.profile().city());

Go

La libreria standard include il pacchetto encoding/json. Di solito i dati si convertono in una struct con i tag sui campi.

package main

import (
    "encoding/json"
    "fmt"
)

type Profile struct {
    City string `json:"city"`
    Age  int    `json:"age"`
}

type User struct {
    Name    string  `json:"name"`
    Profile Profile `json:"profile"`
}

func main() {
    dataStr := `{"name": "Anna", "profile": {"city": "Roma", "age": 29}}`

    var user User
    json.Unmarshal([]byte(dataStr), &user)

    fmt.Println(user.Name)          // Anna
    fmt.Println(user.Profile.City)  // Roma
}

C

Il .NET moderno include lo spazio dei nomi integrato System.Text.Json.

using System;
using System.Text.Json;

class Program
{
    static void Main()
    {
        string dataStr = "{\"name\": \"Anna\", \"profile\": {\"city\": \"Roma\"}}";

        using JsonDocument doc = JsonDocument.Parse(dataStr);
        JsonElement root = doc.RootElement;

        Console.WriteLine(root.GetProperty("name").GetString());                       // Anna
        Console.WriteLine(root.GetProperty("profile").GetProperty("city").GetString()); // Roma
    }
}

PHP

In PHP il parsing è integrato nel linguaggio con le funzioni json_decode e json_encode.

<?php
$dataStr = '{"name": "Anna", "profile": {"city": "Roma", "age": 29}}';

// true: convertire in un array associativo invece che in un oggetto
$data = json_decode($dataStr, true);

echo $data["name"];             // Anna
echo $data["profile"]["city"];  // Roma

// Operazione inversa
$backToStr = json_encode($data, JSON_UNESCAPED_UNICODE);

Rust

Nell’ecosistema Rust lo standard de facto è il crate serde insieme a serde_json.

use serde::Deserialize;

#[derive(Deserialize)]
struct Profile {
    city: String,
    age: u32,
}

#[derive(Deserialize)]
struct User {
    name: String,
    profile: Profile,
}

fn main() {
    let data_str = r#"{"name": "Anna", "profile": {"city": "Roma", "age": 29}}"#;

    let user: User = serde_json::from_str(data_str).unwrap();

    println!("{}", user.name);          // Anna
    println!("{}", user.profile.city);  // Roma
}

Confronto degli approcci

Si notano due approcci principali all’analisi:

• Parsing dinamico — il JSON diventa una struttura generica (dizionario, array, albero di nodi). Comodo per un lavoro rapido e flessibile, ma senza controllo dei tipi in fase di compilazione.
• Parsing tipizzato — il JSON viene mappato subito su classi o struct definite in anticipo. Più sicuro e più chiaro, soprattutto nei linguaggi a tipizzazione rigorosa (Java, Go, Rust, C#).

Problemi frequenti e raccomandazioni

Quando fai parsing di JSON conviene tenere conto di alcune difficoltà tipiche:

• JSON non valido. Se la stringa è danneggiata o contiene errori di sintassi, il parser solleva un’eccezione. L’analisi di dati esterni va sempre avvolta in una gestione degli errori.
• Campi assenti o null. Non dare per scontato che tutte le chiavi attese siano sempre presenti: l’API può inviare un oggetto incompleto. Verifica che il campo esista prima di accedervi.
• Codifica. Lo standard JSON usa UTF-8. In alcuni linguaggi (Python, PHP) bisogna indicare flag espliciti perché i caratteri non ASCII (lettere accentate) non si trasformino in sequenze \u durante la serializzazione.
• Documenti grandi. Per file molto grandi, invece di caricare tutto l’oggetto in memoria si ricorre al parsing in streaming, che legge i dati a blocchi.
• Numeri e precisione. Gli interi grandi e i numeri in virgola mobile possono perdere precisione — un aspetto critico per i dati finanziari, che a volte vengono trasmessi come stringhe.

Conclusione

Il parsing di JSON è una competenza di base senza la quale è quasi impossibile lavorare con le API moderne e scambiare dati tra sistemi. Il formato in sé è universale, e gli strumenti per analizzarlo esistono in ogni linguaggio di programmazione diffuso: a volte integrati, a volte sotto forma di librerie popolari. Il principio è sempre lo stesso — trasformare una stringa di testo in oggetti comodi per il codice e, quando serve, fare il percorso inverso.

Per vedere come il parsing si inserisce nel ciclo completo di interazione con i servizi esterni, consulta l’articolo «Estrazione di dati via API».