Parsing i mobilappar: essens, dataformat och process

Vad är parsning?

Parsning (syntaktisk analys) — processen att omvandla en teckensekvens till en strukturerad representation som är lämplig för programmatisk bearbetning. I sammanhanget av mobil utveckling avser parsning analys av svar från server, konfigurationsfiler, lokal cache och resursfiler. Varje format kräver sin egen metod: JSON — lätt och inbyggt i SDK, XML — strikt med validering av XSD-schema, CSV — minimalistisk för tabelldata, Protobuf — binärt med stelt schema.

Faser av syntaktisk analys

Varje parser, oavsett format, går igenom tre faser. Lexikal analys delar upp råtexten i lexem: nycklar, strängar, tal, avgränsare och kommentarer. Syntaktisk analys kontrollerar grammatisk korrekthet — balans av parenteser i JSON, korrekt häckning av taggar i XML. Konstruktion av utdatastruktur skapar objektrepresentationen: JSONObject, Map eller tokenström för vidare bearbetning. Enligt Apple (2026) använder den inbyggda Foundation-parsern på iOS lat analys — den validerar bara början av JSON och sparar resurser.

Manuell parsning vs automatiska bibliotek

Manuell parsning (JSONSerialization, XmlPullParser) ger full kontroll över processen och är användbar för icke-standardformat eller behovet av anpassad validering av varje fält. Automatiska bibliotek (JSONDecoder, Moshi, kotlinx.serialization) snabbar upp utvecklingen men döljer detaljerna i felhanteringen. Valet beror på kraven: om datastrukturen är dynamisk eller okänd i förväg — manuell parsning är att föredra. Om schemat är fast — automatiskt deserialisering minskar koden med 60–70%.

Skillnaden mellan parsning och deserialisering

Parsning — en bredare operation: kan utföras strömmande och skapar inte nödvändigtvis ett typat objekt. Deserialisering — ett specialfall av parsning, vars resultat alltid är en instans av en på förhand känd klass med konkreta egenskapstyper. En JSON-parser bryter ner dokumentet till Map eller JsonElement, medan en deserialisator omvandlar samma JSON till ett konkret objekt User, Order eller Product med kända fält och deras typer.

Strömmande parsning — den största fördelen med parsning framför deserialisering. XmlPullParser på Android analyserar XML medan den läser, utan att ladda hela dokumentet i arbetsminnet. Detta är kritiskt för stora API-svar, parsning av RSS-flöden med hundratals element eller bearbetning av en array med tusentals JSON-objekt från en serverdump. En strömmande parser läser token för token och förbrukar en konstant mängd minne oavsett dokumentets storlek.

JSON-parsning i mobilappar

JSON — det dominerande datautbytesformatet. På iOS analyserar den inbyggda JSONSerialization JSON till Any, och JSONDecoder — direkt till en Codable-struktur. På Android tillhandahåller standard org.json JSONObject och JSONArray för manuell analys. Gson och Moshi lägger till automatisk konvertering. Valet mellan manuell och automatisk metod — det första arkitekturella beslutet i nätverkslagret.

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")
    // användarbehandling
}

Manuell parsning via org.json är användbart när svarsstrukturen är okänd i förväg eller varierar avsevärt. Denna metod ger full kontroll över felhantering och nullable-fält, men kräver mer standardkod jämfört med automatisk deserialisering. För små projekt eller prototyper är detta acceptabelt, men i produktion rekommenderas Moshi eller kotlinx.serialization.

JSONReader för strömmande analys

JsonReader från Moshi-biblioteket — ett kraftfullt verktyg för strömmande JSON-parsning. Det läser dokumentet token för token med hjälp av metoderna beginObject, nextName, nextString, nextInt och endObject. Denna metod gör det möjligt att bearbeta dokument av valfri storlek med konstant minnesförbrukning. Enligt Google (2026) är strömmande parsning via JsonReader 2–3 gånger snabbare än att ladda hela dokumentet i JsonObject och förbrukar upp till 80% mindre minne.

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()

Exemplet visar JsonReader som tolkar JSON strömmande. Varje anrop till nextName() och nextInt() flyttar markören till nästa token. skipValue() hoppar över onödiga fält utan att tolka dem — detta är särskilt användbart när JSON innehåller 50 fält och endast 3 behövs. Resultatet — minimal minnesförbrukning och maximal hastighet.

XML- och CSV-parsning

XML används fortfarande i Android-projekt för resurser och i SOAP-tjänster för företagsapplikationer. På Android tillhandahåller den inbyggda XmlPullParser strömmande analys med minimal minnesförbrukning — den laddar inte DOM-trädet utan genererar händelser START_TAG, TEXT, END_TAG. iOS använder XMLParser med en delegatmetod: metoderna parser(didStartElement:) och parser(foundCharacters:) bearbetar element sekventiellt.

CSV i mobil utveckling

CSV — det enklaste formatet för export och import av tabelldata. I mobilappar används CSV för export av rapporter, laddning av referensdata (listor över länder, valutor, koder) och synkronisering av offlinedata. För CSV-parsning är strömmande bibliotek lämpliga: Apache Commons CSV och OpenCSV bearbetar filer rad för rad och escapar citationstecken och kommatecken inuti värden. På iOS kan CSV-parsning göras via avgränsaren NSString.components(separatedBy:) med hantering av gränsfall.

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
    }
}

Exempel på XMLParser-delegat på iOS för att tolka ett RSS-flöde. Metoden didStartElement anropas vid varje öppningstag, foundCharacters returnerar textinnehållet mellan taggar, didEndElement avslutar elementet. En sådan händelsestyrd arkitektur möjliggör bearbetning av XML av valfri storlek utan att ladda DOM-trädet i minnet — kritiskt för begränsade resurser hos mobila enheter.

Jämförelse av CSV-bibliotek för Android

På Android beror valet av CSV-parser på datamängden. OpenCSV stöder fluent API, annoteringar för mappning till POJO och anpassade avgränsare. Apache Commons CSV — mer lågnivå, men snabbare på stora filer. För enkla fall (1–2 kolumner) räcker manuell analys via String.split(",") med escapehantering. För produktionsprojekt med stora CSV-filer rekommenderas OpenCSV.

Protobuf och strömmande parsning

Protocol Buffers från Google — ett binärt serialiseringsformat som överträffar JSON i hastighet och kompakthet. Ett Protobuf-meddelande tar 3–6 gånger mindre plats än motsvarande JSON och tolkas 4–10 gånger snabbare tack vare det binära formatet och det stela schemat. Största nackdelarna: brist på läsbarhet för människor och behovet av att generera kod från .proto-filer via protoc-kompilatorn.

Strömmande parsning av Protobuf implementeras via CodedInputStream — klienten läser fält när de anländer utan att ladda hela meddelandet. Varje fält har en tagg (nummer + typ) och parsern kan hoppa över okända fält. Enligt Google (2026) förbrukar strömmande analys av Protobuf upp till 90% mindre minne vid bearbetning av meddelanden från 1 MB, vilket är kritiskt för mobila enheter med begränsat RAM. Protobuf-lite — en speciell version för Android, optimerad för storleken på genererad kod.