JSONSerialization: bu nima, Foundation sinfi metodlari va qanday ishlaydi

JSONSerialization nima

JSONSerialization — iOS, macOS, tvOS va watchOS da mavjud bo'lgan Foundation freymvorkidan sinfdir. U JSON Data-ni Foundation obyektlariga (NSDictionary, NSArray, NSString, NSNumber) va aksincha o'zgartirish uchun metodlarni taqdim etadi. Sinf iOS 5 da paydo bo'ldi va Codable (Swift 4) joriy etilgunga qadar Apple platformalarida JSON bilan ishlashning asosiy usuli bo'lib qoldi. Yoshi ga qaramasdan, JSONSerialization Objective-C dagi eski loyihalarda va qat'iy model sxemasisiz dinamik JSONni qayta ishlash talab qilinadigan stsenariylarda talab qilinmoqda.

JSONSerialization qachon ishlatiladi

Codable paydo bo'lishiga qaramay, JSONSerialization bir nechta stsenariyda dolzarb bo'lib qolmoqda. Dinamik JSON tuzilmasi — javob formati o'zgarganida yoki oldindan noma'lum bo'lganda — kalitlar orqali lug'atlarga murojaat qilishni talab qiladi, buni JSONSerialization orqali qilish osonroq. Sinf shuningdek Codable mavjud bo'lmagan Objective-C loyihalarida va katta JSON fayllarini bosqichma-bosqich pars qilish uchun oqimlar bilan ishlashda qo'llaniladi. Testlar va maketlarda isValidJSONObject va data(withJSONObject:options:) uchinchi tomon kutubxonalarini ulamasdan tezda JSON fiksturlarini yaratishga imkon beradi, bu esa rivojlanish va prototiplashni tezlashtiradi.

import Foundation

// JSONSerialization dan foydalanishning asosiy tuzilmasi
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 pars xatosi: \(error)")
}

Sinfning asosiy metodlari

JSONSerialization JSON bilan ishlash uchun to'rtta asosiy metodni taqdim etadi. Asosiy metod — jsonObject(with:options:), Data-ni Foundation obyektlariga o'zgartiradi. data(withJSONObject:options:) metodi teskari serializatsiyani amalga oshiradi. isValidJSONObject(_:) obyektni serializatsiya qilish mumkinligini tekshiradi. writeJSONObject(_:to:options:error:) JSON-ni to'g'ridan-to'g'ri oqimga yozadi. InputStream dan JSON o'qish uchun Data o'rniga oqim qabul qiladigan jsonObject(with:options:) metodi mavjud bo'lib, bu oqimli ma'lumotlarni qaytaradigan tarmoq so'rovlari bilan integratsiyalashda qulaydir.

JSONObject va JSONData

jsonObject metodi Data qabul qiladi va Any qaytaradi — odatda NSDictionary yoki NSArray. Xavfsiz ishlash uchun natija shartli o'tkazish orqali kutilayotgan turga o'tkaziladi. data metodi Foundation obyektini qabul qiladi va JSON ko'rinishidagi Data ni qaytaradi. .prettyPrinted varianti o'qish qulayligi uchun chekinishlar bilan formatlashni qo'shadi.

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("Mahsulot: \(name)")
        }
    }
}

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

JSON pars qilish misollari

Asosiy pars qilish primitiv turlar bilan lug'atning — JSONSerialization bilan eng keng tarqalgan operatsiya. URLSession orqali Data olgandan so'ng, dasturchi jsonObject ni chaqiradi va natijani kutilgan turga o'tkazadi. Obyekt massivlari uchun [[String: Any]] ga o'tkazish qo'llaniladi, shundan so'ng har bir element siklda qayta ishlanadi. Bu yondashuv moslashuvchan, ammo turlarni qo'lda boshqarishni talab qiladi.

Ichma-ich tuzilmalarni pars qilish

Haqiqiy API lar massivlar, sanalar va ixtiyoriy maydonlar bilan murakkab ichma-ich JSON obyektlarini qaytaradi. JSONSerialization har qanday ichki joylashish chuqurligini to'g'ri qayta ishlaydi, ammo dasturchi har bir darajani mustaqil ravishda kerakli turga o'tkazishi kerak. Bu vazifani soddalashtirish uchun Apple tiplangan ma'lumotlar uchun Codable ni, dinamik tuzilmalar uchun esa faqat JSONSerialization ni ishlatishni tavsiya qiladi.

// API dan javobni pars qilish
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("Foydalanuvchi: \(name) (ID: \(userId))")

    } catch let error as ParsingError {
        print("Pars muvaffaqiyatsiz tugadi: \(error)")
    } catch {
        print("Kutilmagan xato: \(error)")
    }
}

enum ParsingError: Error {
    case missingField
    case invalidType
}

Xatolarni boshqarish

JSONSerialization yaroqsiz JSON, tur mos kelmasligi yoki ichki joylashish chuqurligi oshib ketganda xatolarni chiqaradi. Xatolar CocoaError turiga tegishli bo'lib, muammo tavsifi bilan kodni o'z ichiga oladi. Dasturchi ularni do-catch konstruksiyasi orqali boshqarishi shart, aks holda dastur favqulodda tugaydi. Eng keng tarqalgan xatolar: NSPropertyListReadCorruptError (noto'g'ri JSON) va NSPropertyListReadUnknownError. Har bir xato turi o'z boshqaruv strategiyasini talab qiladi: noto'g'ri formatda ma'lumotlarni qayta yuborishni so'rash kerak, tuzilma mos kelmasligida esa pars modelini yangilash kerak.

Deserializatsiyadagi xato turlari

Yaroqsiz JSON — muvaffaqiyatsizliklarning eng keng tarqalgan sababi: tushib qolgan vergul, ortiqcha belgi yoki to'g'ri ekranlanmagan qo'shtirnoq butun parsni buzadi. Xatolarning ikkinchi turi — kutilgan tuzilma bilan mos kelmaslik: masalan, server lug'at o'rniga massiv qaytardi. JSONSerialization.fragmentsAllowed ildizi lug'at yoki massiv emas, balki primitiv qiymat bo'lgan JSON ni o'qishga imkon beradi. Dasturchi shuningdek JSON juda ko'p ierarxiya darajalarini o'z ichiga olganida ichki joylashish chuqurligi oshib ketishi xatosiga duch kelishi mumkin.

O'qish va yozish variantlari

JSONSerialization parsni sozlash uchun bir nechta variantlarni taqdim etadi. .mutableContainers o'zgarmas versiyalar o'rniga NSMutableDictionary va NSMutableArray qaytaradi, bu parsdan keyin ma'lumotlarni o'zgartirishda foydalidir. .mutableLeaves matn qiymatlarini o'zgartiriladigan qiladi. .fragmentsAllowed ildizi obyekt yoki massiv emas, balki matn yoki raqam bo'lgan JSON ga ruxsat beradi — bu oddiy API javoblari uchun qulay. .withoutEscapingSlashes va .sortedKeys variantlari data(withJSONObject:options:) metodi uchun mavjud bo'lib, serializatsiyalangan JSON formatlashni boshqaradi. Variantlar bit maskasi orqali uzatiladi, bu esa moslashuvchan pars sozlash uchun | operatori orqali bir nechta qiymatlarni birlashtirishga imkon beradi.

// Turli xato turlarini boshqarish
func safeParse(jsonData: Data) {
    do {
        let object = try JSONSerialization
            .jsonObject(with: jsonData,
                           options: .fragmentsAllowed)

        if let dictionary = object as? [String: Any] {
            print("Lug'at \(dictionary.count) kalit bilan")
        } else if let array = object as? [Any] {
            print("Massiv \(array.count) element bilan")
        }

    } catch CocoaError.propertyListReadCorrupt {
        print("Buzilgan JSON ma'lumotlari")
    } catch let error as CocoaError {
        print("Cocoa xatosi: \(error)")
    } catch {
        print("Noma'lum xato: \(error)")
    }
}

// Serializatsiyadan oldin obyektning to'g'riligini tekshirish
let testObject: [String: Any] = ["key": "value", "nested": ["a": 1]]
if JSONSerialization.isValidJSONObject(testObject) {
    print("To'g'ri JSON obyekti")
}

JSONSerialization unumdorligiga ma'lumotlar hajmi va chaqiruvlar chastotasi ta'sir qiladi. Kichik server javobini bir martalik pars qilishda farq sezilmaydi, ammo o'nlab megabayt JSON ni qayta ishlashda yoki sikl ichida tez-tez chaqiruvlarda tur o'tkazish xarajatlarini hisobga olish kerak. JSONSerialization sinxron ishlaydi joriy oqimda, shuning uchun katta hujjatlar uchun DispatchQueue.global() orqali parsni fon navbatiga chiqarish tavsiya etiladi. Muqobil ravishda, butun faylni xotiraga yuklamasdan oqimli qayta ishlash uchun InputStream dan foydalanish mumkin, bu cheklangan resursli ilovalar uchun juda muhimdir. JSON ni faylga yoki tarmoq oqimiga yozish uchun writeJSONObject(_:to:options:error:) metodi oraliq Data obyektini yaratmasdan serializatsiyalangan ma'lumotlarni to'g'ridan-to'g'ri OutputStream ga yo'naltirishga imkon beradi, bu katta hujjatlar bilan ishlashda xotira sarfini kamaytiradi.