Työskentely Codable ja JSON Swift

Kirjoittanut Reinder de Vries 20. tammikuuta 2021 in App Development, iOS, Swift

Voit käyttää Codable:aa Swiftissä koodaamaan ja purkamaan mukautettuja dataformaatteja, kuten JSON, natiiveiksi Swift-objekteiksi. Swift-objektien liittäminen JSON-dataan ja päinvastoin on uskomattoman helppoa yksinkertaisesti ottamalla käyttöön Codable-protokolla.

Käytännöllisenä iOS-kehittäjänä törmäät JSONiin ennemmin tai myöhemmin. Jokainen verkkopalvelu Facebookista Foursquareen käyttää JSON-formaattia saadakseen dataa sovellukseesi ja sovelluksestasi. Miten voit koodata ja purkaa tuon JSON-datan tehokkaasti Swift-objekteiksi?

Tässä opetusohjelmassa opit työskentelemään JSON-objektien kanssa Swiftissä Codable-protokollan avulla. Mitä opit, voidaan helposti soveltaa myös muihin dataformaatteihin. Tutustumme koodaukseen ja dekoodaukseen JSONEncoder:n ja JSONDecoder:n avulla, ja näytän, miten välitämme JSON- ja Swift-datan välillä.

Valmiina? Aloitetaan.

1. Aloitetaan: Encoding and Decoding
2. The Codable Protocol Explained
3. Working with Codable
4. Decoding JSON to Swift Objects with Codable
5. Encoding Swift Objects as JSON with Codable
6. Working with Nested Arrays and Codable
7. Further Reading

Get Started: Encoding and Decoding

Minkä ongelman Swiftin Codable-protokolla oikeastaan ratkaisee? Aloitetaan esimerkillä.

Kuvittele, että olet rakentamassa reseptisovellusta. Sovellus näyttää erilaisia reseptejä listana, sisältäen ainesosat, ohjeet ja perustiedot ruoasta.

Hankit sovelluksen tiedot verkkopalvelusta ja niiden pilvipohjaisesta API:sta. Tämä API käyttää JSON-dataformaattia. Aina kun pyydät reseptin verkkopalvelusta, saat JSON-tiedot takaisin.

Tässä on esimerkki reseptin JSON-tiedoista:

{ "name": "Spaghetti Bolognese", "author": "Reinder's Cooking Corner", "url": "https://cookingcorner.com/spaghetti-bolognese", "yield": 4, "ingredients": , "instructions": "Cook spaghetti, fry beef and garlic, add tomatoes, add love, eat!"}

Katso JSON-tiedon rakennetta.

JSON-objektit kääritään vinosulkeisiin { ja }, ja matriisit kääritään hakasulkeisiin . Ominaisuuksien nimet ovat merkkijonoja, jotka on kiedottu lainausmerkkeihin ". JSON-arvot voivat olla merkkijonoja, numeroita (ilman lainausmerkkejä), matriiseja tai muita objekteja. Voit myös pesäkkeistää dataa, eli matriiseja matriiseissa, objekteja matriiseissa jne. monimutkaisen datahierarkian luomiseksi.

JSON on tekstipohjainen dataformaatti, jota monet verkkopalvelut käyttävät, mukaan lukien Twitterin, Facebookin, Foursquaren ja niin edelleen API:t. Jos rakennat sovelluksia, jotka käyttävät verkkopohjaisia resursseja, törmäät JSONiin.

JSON-muoto on ylivoimainen verrattuna XML:ään, joka on yleinen vaihtoehto, koska se on tehokas, helposti jäsennettävä ja ihmisten luettavissa. JSON on sovittu muoto verkkopalveluille, API:ille ja sovelluksille. Sitä käytetään kaikkialla verkossa, sovelluksissa ja verkkopalveluissa, koska formaatti on yksinkertainen ja joustava.

Ja JSONilla on yksi loistava ominaisuus: voit koodata minkä tahansa dataformaatin JSONiin ja purkaa JSONin takaisin mihin tahansa dataformaattiin. Tämä koodaus- ja dekoodausprosessi tekee JSONista niin tehokkaan.

Voit ottaa Swiftin String-, Int-, Double-, URL-, Date-, Data-, Array– ja Dictionary-arvot ja koodata ne JSONiksi. Sitten lähetät ne verkkopalveluun, joka purkaa arvot sen ymmärtämään natiiviin muotoon. Vastaavasti verkkopalvelu lähettää JSONiksi koodattua dataa sovellukseesi, ja sinä dekoodaat datan natiivityypeiksi, kuten String, Double ja Array.

Kun reseptisovelluksesi vastaanottaa JSONin (ks. edellä), se voidaan dekoodata Swift-rakenteeksi, kuten tämä:

struct Recipe { var name: String var author: String var url: URL var yield: Int var ingredients: var instructions: String}

Swiftissä Codable-protokollaa käytetään siirtymään JSON-dataobjekteista varsinaiseksi Swift-luokaksi tai -rakenteeksi. Tätä kutsutaan dekoodaukseksi, koska JSON-data dekoodataan Swiftin ymmärtämään muotoon. Se toimii myös toisinpäin: Swift-objektien koodaaminen JSONiksi.

Swiftin Codable-protokolla on itse asiassa alias Decodable– ja Encodable-protokollien välillä. Koska koodausta ja dekoodausta käytetään usein yhdessä, käytetään Codable-protokollaa molempien protokollien saamiseksi yhdellä kertaa.

Koodauksen ja dekoodauksen työnkulun keskipiste on Swiftin Codable-protokolla. Selvitetään seuraavaksi, miten se toimii!

The Codable Protocol Explained

JSONin käyttäminen ennen Swift 4:ää oli hieman hankalaa. Sinun täytyi serialisoida JSON itse JSONSerialization:llä ja sitten tyypittää JSON:n jokainen ominaisuus oikeaan Swift-tyyppiin.

let json = try? JSONSerialization.jsonObject(with: data, options: )if let recipe = json as? { if let yield = recipe as? Int { recipeObject.yield = yield }}

Ylläoleva pätkä nappaa JSON:sta vain yield-arvon ja valaa sen Int:ksi. Se on erittäin runsas, ja mahdollisiin virheisiin ja tyyppipoikkeamiin on vaikea reagoida kunnolla. Vaikka se toimii, se ei ole ihanteellinen.

SwiftyJSONin kaltaiset kirjastot tekevät JSONin kanssa työskentelystä paljon helpompaa, mutta JSON-tiedot on silti kuvattava vastaaviin Swift-objekteihin ja -ominaisuuksiin.

Swift 4:ssä ja sitä uudemmissa versioissa voit sen sijaan käyttää Codable-protokollaa. Swift-rakenteesi tai -luokkasi tarvitsee vain omaksua Codable-protokolla, ja saat JSON-koodauksen ja -dekoodauksen suoraan laatikosta, ilmaiseksi.

Codable-protokolla on kooste kahdesta protokollasta, Decodable ja Encodable. Molemmat protokollat ovat melko minimaalisia; ne määrittelevät vain funktiot init(from: Decoder) ja encode(to: Encoder). Toisin sanoen nämä funktiot tarkoittavat, että jotta tyyppi olisi ”dekoodattavissa” tai ”koodattavissa”, sen täytyy ”dekoodata jostain” ja ”koodata johonkin”.

Codable:n todellinen taika tapahtuu Decoder– ja Encoder-protokollien avulla. Nämä protokollat ottavat käyttöön komponentit, jotka koodaavat/dekoodaavat erilaisia dataformaatteja, kuten JSON. Swiftissä meillä on muutama -koodaaja:

• PropertyListEncoder ja PropertyListDecoder .plist-ominaisuusluetteloita varten
• JSONEncoder ja JSONDecoder JSONia varten – se olemme me!
• NSKeyedArchiver voi työskennellä Codable:n kanssa PropertyListEncoder:n, Data:n ja NSCoding:n kautta

JSONDecoder– ja JSONEncoder-luokat käyttävät noita Decoder– ja Encoder-protokollia tarjotakseen toiminnallisuuden JSON:n dekoodaamiseen/enkoodaamiseen. Tämä tarkoittaa myös sitä, että voit kirjoittaa oman mukautetun koodaajan/dekoodaajan Codable:lle, kunhan otat käyttöön Decoder– ja Encoder-protokollat!

Working with Codable

Katsotaanpa esimerkki. Kartoitamme JSON-dataa Swift-rakenteeseen. Käytännössä dekoodaamme JSON:n varsinaiseksi Swift-olioksi.

Aluksi luomme structin nimeltä User. Näin:

struct User: Codable { var first_name: String var last_name: String var country: String}

User-rakenteella on kolme yksinkertaista ominaisuutta, joiden tyyppi on String, ja se noudattaa Codable-protokollaa.

Kirjoitetaan sitten vähän JSONia. Tämän JSONin kanssa työskentelemme:

{ "first_name": "John", "last_name": "Doe", "country": "United Kingdom"}

JSON-data tulee sovellukseesi tyypillisesti verkkopalvelupyynnön vastauksena tai .json-tiedoston kautta, mutta tässä esimerkissä laitamme JSONin yksinkertaisesti String-rakenteeseen. Näin:

let jsonString = """{ "first_name": "John", "last_name": "Doe", "country": "United Kingdom"}"""

Seuraavaksi puramme JSONin ja muutamme sen User-olioksi. Näin:

let jsonData = jsonString.data(using: .utf8)!let user = try! JSONDecoder().decode(User.self, from: jsonData)print(user.last_name)// Output: Doe

Tässä tapahtuu näin:

• Ensin muutat jsonString:n Data-olioksi kutsumalla data(using:)-funktiota merkkijonoon. Tämä on välttämätön välivaihe.
• Sitten luot JSONDecoder-olion ja kutsut siihen välittömästi decode(_:from:)-funktiota. Tämä muuttaa jsonData:n User-tyyppiseksi objektiksi purkamalla JSONin. Tyyppi User.self annetaan parametrina.
• Tulostat lopuksi käyttäjän sukunimen print(user.last_name):lla. Tuon user arvon tyyppinä on User, joten se on varsinainen Swift-objekti!

Ehelppoa, eikö? Olet periaatteessa ”kartoittanut” JSON-objektin Swift-rakenteeksi ja purkanut JSON-muodon natiiviksi objektiksi, jonka kanssa Swift voi työskennellä.

Yllä olevassa koodissa jätämme huomiotta kaikki virheet, jotka decode(_:from:) heittää try!:llä. Omassa koodissasi sinun on käsiteltävä virheet do-try-catch-lohkolla. Virhe, joka voidaan heittää, tulee esimerkiksi virheellisen JSONin antamisesta.

User.self on metatyyppi, viittaus itse tyyppiin User. Kerromme dekooderille, että haluamme dekoodata datan User-rakenteella, antamalla sille viittauksen kyseiseen tyyppiin.

JSON:n dekoodaaminen Swift-objekteiksi Codable-ohjelmalla

Katsotaanpa vielä edellisen kappaleen esimerkkiä ja laajennetaan sitä. Tässä on JSON, jonka kanssa työskentelemme:

let jsonString = """{ "first_name": "John", "last_name": "Doe", "country": "United Kingdom"}"""

Muutamme sen sitten Data-olioksi. Näin:

let jsonData = jsonString.data(using: .utf8)!

Tämä on välttämätön välivaihe. Sen sijaan, että esittäisimme JSONin merkkijonona, tallennamme sen nyt natiivina Data-objektina. Merkistökoodaus, jota käytämme tuolle merkkijonolle, on UTF8.

Jos katsot tarkkaan, huomaat, että yllä oleva koodi käyttää force unwrappingia toimiakseen data(using:):n valinnaisen paluuarvon kanssa. Puretaan tuo valinnainen tyylikkäämmin!

if let jsonData = jsonString.data(using: .utf8) { // Use `jsonData`} else { // Respond to error }

Yllä olevalla koodilla voimme reagoida virheisiin, kun data(using:) palauttaa nil. Voit esimerkiksi näyttää virheilmoituksen tai antaa tehtävän epäonnistua hiljaa ja tallentaa diagnostiikkatiedot lokiin.

Seuraavaksi luomme uuden JSONDecoder-olion. Näin:

let decoder = JSONDecoder()

Käytämme sitten tuota dekooderia JSON-datan purkamiseen. Näin:

let user = try! decoder.decode(User.self, from: jsonData)

Mutta decode(_:from:)-funktio voi heittää virheitä. Yllä oleva koodi kaatuu aina kun näin tapahtuu. Haluamme taas reagoida kaikkiin mahdollisiin virheisiin. Näin:

do { let user = try decoder.decode(User.self, from: jsonData) print(user.last_name)} catch { print(error.localizedDescription)}

Ja koko koodilohko näyttää nyt seuraavalta. Näetkö, miten tämä on erilaista?

if let jsonData = jsonString.data(using: .utf8){ let decoder = JSONDecoder() do { let user = try decoder.decode(User.self, from: jsonData) print(user.last_name) } catch { print(error.localizedDescription) }}

Työskentely CodingKeysin kanssa

Mitä jos JSON-ominaisuutemme, kuten first_name ja/tai firstName, eroavat Swift-rakenteen ominaisuuksista? Silloin CodingKeys astuu kuvaan.

Jokainen Codable:n mukainen luokka tai rakenne voi ilmoittaa erityisen sisäkkäisen luettelon nimeltä CodingKeys. Sitä käytetään määrittelemään koodattavat ja dekoodattavat ominaisuudet ja niiden nimet.

Katsotaanpa esimerkkiä. Alla olevassa User-rakenteessa olemme muuttaneet ominaisuuksien nimet snake_case:sta camelCase:ksi. Esimerkiksi avain first_name on nyt nimeltään firstName.

struct User:Codable { var firstName: String var lastName: String var country: String enum CodingKeys: String, CodingKey { case firstName = "first_name" case lastName = "last_name" case country }}

Kun käytät yllä olevaa rakennetta edellisten osioiden esimerkkien kanssa, huomaat, että voit käyttää User-objektia uusilla ominaisuuksien nimillä. Näin:

print(user.firstName)// Output: Johnprint(user.country)// Output: United Kingdom

CodingKeys-luettelo kuvaa sen tapaukset ominaisuuksiksi ja käyttää merkkijonoarvoja oikeiden ominaisuuksien nimien valitsemiseen JSON-tiedoissa. Enumissa oleva case on sen ominaisuuden nimi, jota haluat käyttää structissa, ja sen arvo on JSON-datassa olevan avaimen nimi.

Swift-objektien koodaaminen JSON:ksi Codable:lla

Tähän mennessä olemme keskittyneet JSON-datan purkamiseen Swift-objekteiksi. Entäpä jos menisimme toiseen suuntaan? Voimmeko myös koodata objekteja JSONiksi? Kyllä, miksipä ei!

var user = User()user.firstName = "Bob"user.lastName = "and Alice"user.country = "Cryptoland"let jsonData = try! JSONEncoder().encode(user)let jsonString = String(data: jsonData, encoding: .utf8)!print(jsonString)

Ja tuloste on:

{"country":"Cryptoland","first_name":"Bob","last_name":"and Alice"}

Mitä tässä tapahtuu?

• Aluksi luodaan User-objekti ja annetaan joitakin arvoja sen ominaisuuksille
• Sitten käytetään encode(_:) koodaamaan user-objekti JSON Data-objektiksi
• Viimeiseksi, muunnat Data-objektin String:ksi ja tulostat sen

Jos katsot tarkkaan, huomaat, että koodaus noudattaa samoja vaiheita kuin dekoodaus, paitsi päinvastoin. Swift-objektista mennään dekooderin läpi, jolloin tuloksena on JSON-merkkijono.

Voidaanko esimerkkiä laajentaa virheiden käsittelyyn kuten ennenkin? Kyllä! Näin:

let encoder = JSONEncoder()encoder.outputFormatting = .prettyPrinteddo { let jsonData = try encoder.encode(user) if let jsonString = String(data: jsonData, encoding: .utf8) { print(jsonString) }} catch { print(error.localizedDescription)}

Yllä olevassa esimerkissä käytämme myös kooderin outputFormatting-ominaisuutta JSON-datan ”kaunistamiseen”. Tämä lisää välilyöntejä, tabulaattoreita ja rivinvaihtoja, jotta JSON-merkkijono olisi helpompi lukea. Näin:

{ "country" : "Cryptoland", "first_name" : "Bob", "last_name" : "and Alice"}

Hienoa!

Työskentely sisäkkäisten joukkojen ja koodattavien kanssa

Tähän mennessä olemme työskennelleet yksinkertaisten JSON-objektien kanssa – vain luokan, jolla on muutama ominaisuus. Mutta entä jos työstämäsi data on monimutkaisempaa?

Esimerkiksi Twitterin tai Facebookin verkkopalvelusta mahdollisesti saamasi JSON-data on usein sisäkkäistä. Toisin sanoen data, johon haluat päästä käsiksi, on hautautunut 2-3 tasolle JSON-massojen ja sanakirjojen joukkoon. Mitä nyt?

Katsotaan ensin yksinkertaista esimerkkiä. Tässä on Swift-rakenne, jonka kanssa työskentelemme:

struct User: Codable { var first_name: String var last_name: String}

Tässä on JSON-data, jonka haluamme purkaa:

let jsonString = """"""

Jos katsot tarkkaan, huomaat, että tarvitsemamme data on tallennettu array-muodossa. JSON ei ole yksi yksinkertainen objekti, vaan se on array, jossa on 3 User-objektia. Tiedämme, että se on objektien joukko, koska siinä on hakasulkeet (joukko) ja vinosulkeet { } (objekti). Useat kohteet erotetaan aina pilkuilla.

Miten voimme purkaa nämä User objektit? Näin:

let jsonData = jsonString.data(using: .utf8)!let users = try! JSONDecoder().decode(.self, from: jsonData)for user in users { print(user.first_name)}

Ylläoleva koodinpätkä on erittäin samankaltainen kuin aiemmin näkemäsi, mutta siinä on yksi tärkeä ero. Näetkö tyypin, jonka annamme decode(_:from:)-funktiolle? Tyyppi on (jossa on .self) eli ”array of User objects”. Sen sijaan, että työskentelisimme yhden User-objektin kanssa, haluamme purkaa joukon niitä, ja se osoitetaan -matriisityypillä.

Jatkossa käsittelemme, miten voit työskennellä monimutkaisempien sisäkkäisten tyyppien kanssa. Ajatellaan esimerkiksi, että User-objektien joukko on sisäkkäin JSON-sanakirjan sisällä. Näin:

let jsonString = """{ "users": }"""

Yllä olevassa JSON-pätkässä ylimmän tason elementti on sanakirja (tai ”objekti”). Sillä on vain yksi avain-arvopari: users-joukko. Haluamamme tiedot ovat tuon matriisin sisällä. Miten pääsemme siihen käsiksi?

On tärkeää, että lähestymistapamme ei ole liian monimutkainen. On helppo ajatella, että tarvitsemme kehittynyttä JSON-parsingia, mutta kuten käy ilmi, voimme itse asiassa myös pesiä Swift-rakenteita. Kuvaamme koko JSONin rakenteena, jonka sisällä on User-rakenne.

Katso tämä:

struct Response: Codable{ struct User: Codable { var first_name: String var last_name: String } var users: }

Katso tämä:

• Ylimmän tason JSON-sanakirja vastaa Response-tyyppiä. Aivan kuten ennenkin, tämä tyyppi on Codable:n mukainen JSON-koodauksen ja -dekoodauksen tukemiseksi.
• Tämän structin sisällä olemme määritelleet toisen structin nimeltä User. Tämä on täsmälleen sama tyyppi, jota olemme käyttäneet aiemminkin. Tämä struct on ”sisäkkäinen”.
• Tässä Response structissa on yksi ominaisuus nimeltä users, jonka tyyppi on eli array of User-objekteja.

Hienoa on, että semanttisesti sekä JSON- että Swift-tietorakenteet ovat täsmälleen samat. Ne vain käyttävät eri syntaksia. Olemme määritelleet päällimmäisen sanakirjan sisälle sisäkkäisen matriisin, aivan kuten Response-rakenteella on sisäkkäinen User-rakenne ja users-ominaisuus sen sisällä.

Sen tekeminen on nyt lastenleikkiä. Katso tätä:

let jsonData = jsonString.data(using: .utf8)!let response = try! JSONDecoder().decode(Response.self, from: jsonData)for user in response.users { print(user.first_name)}

Näetkö, miten käytämme Response-tyyppiä JSONin purkamiseen ja sitten silmukoimme response.users-ominaisuutta? Tarkista se Response-rakenteen ja JSONin avulla. Poimimme users-avain-arvoparin ylimmän tason sanakirjasta, ja kartoitamme sen sisällä olevat objektit User-objekteiksi. Siistiä!

Lisälukemista

Ja siinä kaikki! Tiedät nyt:

• Miten Codable:n avulla luodaan objekteja, jotka voidaan koodata ja purkaa
• Miten JSONDecoder:n ja JSONEncoder:n avulla koodataan ja puretaan JSON-objekteja ja niiden Swift-vastineita
• Mitä varten koodaaminen ja purkaminen on, ja miksi se on tärkeää jokapäiväisessä iOS-kehityksessä
• Miten työskennellä monimutkaisempien JSON-tietojen kanssa ja miten käyttää sisäkkäisiä tyyppejä

Haluatko oppia lisää? Tutustu näihin resursseihin:

• Arrays, Dictionaries and Structs
• Working With JSON In Swift With SwiftyJSON
• Introduction Of Object-Oriented Programming In Swift
• How To: Find An Item In An Array In Swift
• How To Use Apple’s Developer Documentation For Fun And Profit
• How To Find Strings With Regular Expressions In Swift
• Why App Architecture Matters
• Strings in Swift Explained
• Working with Files on iOS with Swift
• Storing Data with NSCoding and NSKeyedArchiver