JSONSerialization: wat is het, methoden van de Foundation-klasse en hoe het werkt

Wat is JSONSerialization

JSONSerialization — is een klasse uit het Foundation-framework, beschikbaar op iOS, macOS, tvOS en watchOS. Het biedt methoden voor het omzetten van JSON Data naar Foundation-objecten (NSDictionary, NSArray, NSString, NSNumber) en vice versa. De klasse verscheen in iOS 5 en bleef tot de introductie van Codable (Swift 4) de belangrijkste manier om met JSON te werken op Apple-platforms. Ondanks zijn leeftijd blijft JSONSerialization gevraagd in legacy-projecten op Objective-C en in scenario's waar dynamische JSON-verwerking vereist is zonder een vast modelschema.

Wanneer wordt JSONSerialization gebruikt

Ondanks de komst van Codable blijft JSONSerialization relevant in verschillende scenario's. Dynamische JSON-structuur — wanneer het antwoordformaat verandert of vooraf onbekend is — vereist toegang tot woordenboeken via sleutels, wat eenvoudiger te doen is via JSONSerialization. De klasse wordt ook gebruikt in Objective-C-projecten waar Codable niet beschikbaar is, en bij het werken met streams voor gefaseerd parsen van grote JSON-bestanden. In tests en mock-ups maken isValidJSONObject en data(withJSONObject:options:) het mogelijk om snel JSON-fixtures te genereren zonder externe bibliotheken aan te sluiten, wat de ontwikkeling en prototyping versnelt.

import Foundation

// Basisstructuur van het gebruik van JSONSerialization
let jsonString = """
{
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
}
"""

guard let jsonData = jsonString.data(using: .utf8) else {
    return
}

do {
    let json = try JSONSerialization
        .jsonObject(with: jsonData,
                       options: .mutableContainers)
    print(json)
} catch {
    print("JSON-parsingfout: \(error)")
}

Belangrijkste methoden van de klasse

JSONSerialization biedt vier hoofdmethoden voor het werken met JSON. De belangrijkste methode — jsonObject(with:options:), die Data omzet in Foundation-objecten. De methode data(withJSONObject:options:) voert omgekeerde serialisatie uit. isValidJSONObject(_:) controleert of een object kan worden geserialiseerd. writeJSONObject(_:to:options:error:) schrijft JSON rechtstreeks naar een stream. Voor het lezen van JSON uit InputStream is er de methode jsonObject(with:options:), die een stream accepteert in plaats van Data, wat handig is bij integratie met netwerkverzoeken die streamgegevens retourneren.

JSONObject en JSONData

De methode jsonObject accepteert Data en retourneert Any — meestal NSDictionary of NSArray. Voor veilig werken wordt het resultaat via voorwaardelijke conversie naar het verwachte type omgezet. De methode data accepteert een Foundation-object en retourneert Data met JSON-weergave. De optie .prettyPrinted voegt opmaak met inspringingen toe voor leesbaarheid.

let jsonString = """
{
    "products": [
        {"id": 1, "name": "iPhone", "price": 999},
        {"id": 2, "name": "iPad", "price": 799}
    ]
}
"""
let data = Data(jsonString.utf8)

if let json = try? JSONSerialization
    .jsonObject(with: data) as? [String: Any],
    let products = json["products"] as? [[String: Any]] {

    for product in products {
        if let name = product["name"] as? String {
            print("Product: \(name)")
        }
    }
}

// Omgekeerde serialisatie: object -> JSON
let outputDict: [String: Any] = ["status": "ok", "count": 42]
if let outputData = try? JSONSerialization
    .data(withJSONObject: outputDict,
                options: .prettyPrinted) {
    String(data: outputData, encoding: .utf8)
}

Voorbeelden van JSON-parsing

Basis parsing van een woordenboek met primitieve typen — de meest voorkomende bewerking met JSONSerialization. Na het ontvangen van Data via URLSession roept de ontwikkelaar jsonObject aan en zet het resultaat om naar het verwachte type. Voor arrays van objecten wordt conversie naar [[String: Any]] gebruikt, waarna elk element in een lus wordt verwerkt. Deze aanpak is flexibel maar vereist handmatig typebeheer.

Parsen van geneste structuren

Echte API's retourneren complexe geneste JSON-objecten met arrays, datums en optionele velden. JSONSerialization verwerkt elke nestdiepte correct, maar de ontwikkelaar moet elk niveau onafhankelijk naar het vereiste type converteren. Om deze taak te vereenvoudigen beveelt Apple het gebruik van Codable aan voor getypeerde gegevens en JSONSerialization alleen voor dynamische structuren.

// Parsen van API-antwoord
func parseUserResponse(data: Data) {
    do {
        guard let json = try JSONSerialization
            .jsonObject(with: data) as? [String: Any]
        else { return }

        guard let userId = json["id"] as? Int,
              let name = json["name"] as? String
        else {
            throw ParsingError.missingField
        }

        print("Gebruiker: \(name) (ID: \(userId))")

    } catch let error as ParsingError {
        print("Parsen mislukt: \(error)")
    } catch {
        print("Onverwachte fout: \(error)")
    }
}

enum ParsingError: Error {
    case missingField
    case invalidType
}

Foutafhandeling

JSONSerialization genereert fouten bij ongeldige JSON, type-mismatch of overschrijding van de nestdiepte. Fouten zijn van het type CocoaError en bevatten een code met een beschrijving van het probleem. De ontwikkelaar is verplicht deze af te handelen via een do-catch constructie, anders zal de applicatie abrupt worden beëindigd. De meest voorkomende fouten: NSPropertyListReadCorruptError (onjuiste JSON) en NSPropertyListReadUnknownError. Elk fouttype vereist zijn eigen afhandelingsstrategie: bij een ongeldig formaat moet opnieuw verzenden van gegevens worden aangevraagd, bij structuurmismatch moet het parsermodel worden bijgewerkt.

Fouttypen bij deserialisatie

Ongeldige JSON — de meest voorkomende oorzaak van fouten: een ontbrekende komma, overtollig teken of niet-escaped aanhalingsteken verbreekt de hele parsing. Het tweede type fouten — mismatch met de verwachte structuur: bijvoorbeeld de server retourneerde een array in plaats van een woordenboek. JSONSerialization.fragmentsAllowed maakt het mogelijk om JSON te lezen waarvan de root geen woordenboek of array is, maar een primitieve waarde. De ontwikkelaar kan ook de fout van overschrijding van de nestdiepte tegenkomen wanneer JSON teveel hiërarchieniveaus bevat.

Lees- en schrijfopties

JSONSerialization biedt verschillende opties voor het configureren van parsing. .mutableContainers retourneert NSMutableDictionary en NSMutableArray in plaats van onveranderlijke versies, wat handig is bij het wijzigen van gegevens na parsing. .mutableLeaves maakt tekstwaarden wijzigbaar. .fragmentsAllowed staat JSON toe waarvan de root geen object of array is, maar een tekenreeks of getal — handig voor eenvoudige API-antwoorden. De opties .withoutEscapingSlashes en .sortedKeys zijn beschikbaar voor de methode data(withJSONObject:options:) en beheren de opmaak van geserialiseerde JSON. Opties worden doorgegeven via een bitmasker, wat het mogelijk maakt om meerdere waarden te combineren via de operator | voor flexibele configuratie van parsing.

// Afhandeling van verschillende fouttypen
func safeParse(jsonData: Data) {
    do {
        let object = try JSONSerialization
            .jsonObject(with: jsonData,
                           options: .fragmentsAllowed)

        if let dictionary = object as? [String: Any] {
            print("Woordenboek met \(dictionary.count) sleutels")
        } else if let array = object as? [Any] {
            print("Array met \(array.count) items")
        }

    } catch CocoaError.propertyListReadCorrupt {
        print("Beschadigde JSON-gegevens")
    } catch let error as CocoaError {
        print("Cocoa-fout: \(error)")
    } catch {
        print("Onbekende fout: \(error)")
    }
}

// Controleren van objectvaliditeit voor serialisatie
let testObject: [String: Any] = ["key": "value", "nested": ["a": 1]]
if JSONSerialization.isValidJSONObject(testObject) {
    print("Geldig JSON-object")
}

De prestaties van JSONSerialization worden beïnvloed door de gegevensgrootte en de frequentie van aanroepen. Bij eenmalig parsen van een klein serverantwoord is het verschil niet merkbaar, maar bij het verwerken van tientallen megabytes JSON of frequente aanroepen in lussen moet rekening worden gehouden met de overhead van typeconversie. JSONSerialization werkt synchroon in de huidige thread, daarom wordt voor grote documenten aanbevolen om parsing naar een achtergrondwachtrij te verplaatsen via DispatchQueue.global(). Als alternatief kan InputStream worden gebruikt voor streamverwerking zonder het hele bestand in het geheugen te laden, wat cruciaal is voor toepassingen met beperkte resources. Voor het schrijven van JSON naar een bestand of netwerkstream maakt de methode writeJSONObject(_:to:options:error:) het mogelijk om geserialiseerde gegevens rechtstreeks naar OutputStream te sturen zonder een tussenliggend Data-object te maken, wat het geheugengebruik bij het werken met grote documenten vermindert.