Parsing nelle app mobili: essenza, formati di dati e processo

Cos'è il parsing?

Parsing (analisi sintattica) è il processo di conversione di una sequenza di caratteri in una rappresentazione strutturata adatta all'elaborazione programmatica. Nel contesto dello sviluppo mobile, il parsing si riferisce all'elaborazione di risposte del server, file di configurazione, cache locale e file di risorse. Ogni formato richiede il proprio approccio: JSON — leggero e integrato nell'SDK, XML — rigoroso con validazione dello schema XSD, CSV — minimalista per dati tabellari, Protobuf — binario con schema rigido.

Fasi dell'analisi sintattica

Qualsiasi parser, indipendentemente dal formato, attraversa tre fasi. Analisi lessicale divide il testo grezzo in token: chiavi, stringhe, numeri, deliminatori e commenti. Analisi sintattica verifica la correttezza grammaticale — bilanciamento delle parentesi in JSON, corretta annidatura dei tag in XML. Costruzione della struttura di output forma una rappresentazione a oggetti: JSONObject, Map o un flusso di token per l'elaborazione successiva. Secondo Apple (2026), il parser Foundation integrato su iOS utilizza l'analisi pigra — valida solo l'inizio del JSON, risparmiando risorse.

Parsing manuale vs librerie automatizzate

Parsing manuale (JSONSerialization, XmlPullParser) offre il controllo completo sul processo ed è utile per formati non standard o quando è necessaria una validazione personalizzata di ogni campo. Librerie automatizzate (JSONDecoder, Moshi, kotlinx.serialization) accelerano lo sviluppo ma nascondono i dettagli della gestione degli errori. La scelta dipende dai requisiti: se la struttura dei dati è dinamica o sconosciuta in anticipo — il parsing manuale è preferibile. Se lo schema è fisso — la deserializzazione automatizzata riduce il codice del 60-70%.

Come il parsing differisce dalla deserializzazione

Parsing è un'operazione più ampia: può essere eseguita in modalità streaming e non crea necessariamente un oggetto tipizzato. Deserializzazione è un caso specifico di parsing il cui risultato è sempre un'istanza di una classe nota con tipi di proprietà specifici. Un parser JSON scompone un documento in Map o JsonElement, mentre un deserializzatore trasforma lo stesso JSON in un oggetto User, Order o Product con campi e tipi noti.

Parsing in streaming è il principale vantaggio del parsing rispetto alla deserializzazione. XmlPullParser su Android analizza XML durante la lettura, senza caricare l'intero documento in RAM. Questo è critico per risposte API di grandi dimensioni, analisi di feed RSS con centinaia di elementi o elaborazione di array di migliaia di oggetti JSON da un dump del server. Un parser in streaming legge token per token, consumando una quantità costante di memoria indipendentemente dalla dimensione del documento.

Parsing JSON nelle app mobili

JSON è il formato di scambio dati dominante. Su iOS, JSONSerialization integrato analizza JSON in Any, mentre JSONDecoder analizza direttamente in una struttura Codable. Su Android, org.json standard fornisce JSONObject e JSONArray per l'analisi manuale. Gson e Moshi aggiungono conversione automatica. Scegliere tra approcci manuali e automatizzati è la prima decisione architetturale del livello di rete.

val jsonString = """{"users":[{"id":1,"name":"Alice"}]}"""
val jsonObject = JSONObject(jsonString)
val usersArray = jsonObject.getJSONArray("users")

for (i in 0 until usersArray.length()) {
    val item = usersArray.getJSONObject(i)
    val id = item.getInt("id")
    val name = item.getString("name")
    // elaborazione utente
}

Parsing manuale tramite org.json è utile quando la struttura della risposta è sconosciuta in anticipo o varia notevolmente. Questo approccio offre il controllo completo sulla gestione degli errori e sui campi nullable, ma richiede più codice boilerplate rispetto alla deserializzazione automatizzata. Per progetti piccoli o prototipi è accettabile, ma in produzione sono preferiti Moshi o kotlinx.serialization.

JsonReader per il parsing in streaming

JsonReader della libreria Moshi è un potente strumento per il parsing JSON in streaming. Legge il documento token per token usando metodi come beginObject, nextName, nextString, nextInt ed endObject. Questo approccio consente di elaborare documenti di qualsiasi dimensione con un consumo di memoria costante. Secondo Google (2026), il parsing in streaming tramite JsonReader è 2-3 volte più veloce del caricamento dell'intero documento in un JsonObject e consuma fino all'80% di memoria in meno.

val reader = JsonReader(StringReader(json))
reader.beginObject()
while (reader.hasNext()) {
    val name = reader.nextName()
    when (name) {
        "id" -> val id = reader.nextInt()
        "name" -> val name = reader.nextString()
        "email" -> val email = reader.nextString()
        else -> reader.skipValue()
    }
}
reader.endObject()

L'esempio mostra JsonReader che analizza JSON in modalità streaming. Ogni chiamata a nextName() e nextInt() sposta il cursore al token successivo. skipValue() salta i campi non necessari senza analizzarli — particolarmente utile quando JSON contiene 50 campi ma ne servono solo 3. Il risultato è un consumo di memoria minimo e la massima velocità.

Parsing XML e CSV

XML continua ad essere utilizzato nei progetti Android per le risorse e nei servizi SOAP delle applicazioni aziendali. Su Android, XmlPullParser integrato fornisce parsing in streaming con consumo di memoria minimo — non carica un albero DOM ma genera eventi START_TAG, TEXT, END_TAG. iOS utilizza XMLParser con un approccio delegato: i metodi parser(didStartElement:) e parser(foundCharacters:) gestiscono gli elementi sequenzialmente.

CSV nello sviluppo mobile

CSV è il formato più semplice per esportare e importare dati tabellari. Nelle app mobili, CSV viene utilizzato per l'esportazione di report, il caricamento di dati di riferimento (elenchi di paesi, valute, codici) e la sincronizzazione di dati offline. Le librerie di streaming sono adatte per il parsing CSV: Apache Commons CSV e OpenCSV elaborano i file riga per riga, escapeando virgolette e virgole all'interno dei valori. Su iOS, il parsing CSV può essere implementato tramite il metodo delimitatore NSString.components(separatedBy:) con gestione dei casi limite.

class CSVParser: NSObject, XMLParserDelegate {
    private var currentItem: [String: String] = [:]
    private var currentElement: String = ""

    func parser(
        _ parser: XMLParser,
        didStartElement elementName: String,
        namespaceURI: String?,
        qualifiedName qName: String?,
        attributes attributeDict: [String: String]
    ) {
        currentElement = elementName
        if elementName == "item" {
            currentItem = [:]
        }
    }

    func parser(_ parser: XMLParser,
                foundCharacters string: String) {
        currentItem[currentElement] = string
    }
}

Esempio di un delegato XMLParser su iOS per analizzare un feed RSS. Il metodo didStartElement viene chiamato su ogni tag di apertura, foundCharacters restituisce il contenuto testuale tra i tag, didEndElement completa l'elemento. Questa architettura basata su eventi consente di elaborare XML di qualsiasi dimensione senza caricare un albero DOM in memoria — critico per le risorse limitate dei dispositivi mobili.

Confronto delle librerie CSV per Android

Su Android, la scelta del parser CSV dipende dal volume di dati. OpenCSV supporta un'API fluida, annotazioni per il mapping POJO e deliminatori personalizzati. Apache Commons CSV è di livello più basso ma più veloce su file grandi. Per casi semplici (1-2 colonne), il parsing manuale tramite String.split(",") con gestione dell'escape è sufficiente. Per progetti di produzione con file CSV di grandi dimensioni, OpenCSV è raccomandato.

Protobuf e parsing in streaming

Protocol Buffers di Google è un formato di serializzazione binario che supera JSON in velocità e compattezza. Un messaggio Protobuf occupa 3-6 volte meno spazio del JSON equivalente e viene analizzato 4-10 volte più velocemente grazie al suo formato binario e allo schema rigido. Gli svantaggi principali sono la mancanza di leggibilità umana e la necessità di generare codice da file .proto tramite il compilatore protoc.

Parsing in streaming di Protobuf è implementato tramite CodedInputStream — il client legge i campi man mano che arrivano senza caricare l'intero messaggio. Ogni campo ha un tag (numero + tipo) e il parser può saltare i campi sconosciuti. Secondo Google (2026), il parsing in streaming di Protobuf consuma fino al 90% di memoria in meno nell'elaborazione di messaggi da 1 MB, il che è critico per i dispositivi mobili con RAM limitata. Protobuf-lite è una versione speciale per Android, ottimizzata per la dimensione del codice generato.