Arbeiten mit Codable und JSON in Swift

Geschrieben von Reinder de Vries am 20. Januar 2021 in App Entwicklung, iOS, Swift

Sie können Codable in Swift verwenden, um benutzerdefinierte Datenformate, wie JSON, in native Swift-Objekte zu kodieren und zu dekodieren. Es ist unglaublich einfach, Swift-Objekte auf JSON-Daten abzubilden und umgekehrt, indem Sie einfach das Codable-Protokoll übernehmen.

Als pragmatischer iOS-Entwickler werden Sie eher früher als später auf JSON stoßen. Jeder Webservice, von Facebook bis Foursquare, verwendet das JSON-Format, um Daten in und aus Ihrer App zu erhalten. Wie können Sie diese JSON-Daten effektiv in Swift-Objekte kodieren und dekodieren?

In diesem Tutorial lernen Sie, wie Sie mit JSON-Objekten in Swift arbeiten können, indem Sie das Codable-Protokoll verwenden. Was Sie lernen, lässt sich auch auf andere Datenformate anwenden. Wir werden uns mit der Kodierung und Dekodierung mit JSONEncoder und JSONDecoder beschäftigen, und ich zeige dir, wie du zwischen JSON- und Swift-Daten vermitteln kannst.

Bereit? Los geht’s.

1. Beginnen Sie: Kodierung und Dekodierung
2. Das Codable-Protokoll erklärt
3. Arbeiten mit Codable
4. JSON mit Codable in Swift-Objekte dekodieren
5. Swift-Objekte mit Codable als JSON kodieren
6. Arbeiten mit verschachtelten Arrays und Codable
7. Weiteres Lesen

Anfangen: Kodierung und Dekodierung

Welches Problem löst das Codable-Protokoll in Swift eigentlich? Beginnen wir mit einem Beispiel.

Stellen Sie sich vor, Sie bauen eine Rezept-App. Die App zeigt verschiedene Rezepte in einer Liste an, einschließlich der Zutaten, Anweisungen und grundlegenden Informationen über Lebensmittel.

Sie erhalten die Daten für die App von einem Webservice und dessen Cloud-basierter API. Diese API verwendet das JSON-Datenformat. Jedes Mal, wenn Sie ein Rezept vom Webservice anfordern, erhalten Sie JSON-Daten zurück.

Hier ist ein Beispiel für JSON-Daten für ein Rezept:

{ "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!"}

Werfen Sie einen Blick auf die Struktur der JSON-Daten.

JSON-Objekte sind in verschnörkelte Klammern { und } und Arrays in eckige Klammern verpackt. Eigenschaftsnamen sind Zeichenketten, die in Anführungszeichen " eingeschlossen sind. Werte in JSON können Strings, Zahlen (ohne Anführungszeichen), Arrays oder andere Objekte sein. Sie können auch Daten verschachteln, d. h. Arrays in Arrays, Objekte in Arrays usw., um eine komplexe Datenhierarchie zu erstellen.

JSON ist ein textbasiertes Datenformat, das von vielen Webservices verwendet wird, darunter APIs von Twitter, Facebook, Foursquare usw. Wenn Sie Anwendungen entwickeln, die webbasierte Ressourcen nutzen, werden Sie auf JSON stoßen.

Das JSON-Format ist XML, einer gängigen Alternative, überlegen, da es effizient, leicht zu parsen und von Menschen lesbar ist. JSON ist ein vereinbartes Format für Webservices, APIs und Anwendungen. Es wird überall im Web, in Anwendungen und Online-Diensten verwendet, weil das Format einfach und flexibel ist.

Und JSON hat eine hervorragende Fähigkeit: Sie können jedes Datenformat in JSON kodieren und JSON in jedes Datenformat zurückdekodieren. Dieser Kodierungs- und Dekodierungsprozess ist es, der JSON so leistungsfähig macht.

Sie können Ihre Swift-Werte String, Int, Double, URL, Date, Data, Array und Dictionary nehmen und sie als JSON kodieren. Anschließend senden Sie sie an den Webservice, der die Werte in ein für ihn verständliches Format dekodiert. Auf ähnliche Weise sendet der Webservice als JSON kodierte Daten an Ihre App, und Sie dekodieren die Daten in native Typen wie String, Double und Array.

Wenn Ihre Rezept-App das JSON empfängt (siehe oben), kann es dann in eine Swift-Struktur wie diese dekodiert werden:

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

In Swift wird das Codable-Protokoll verwendet, um von einem JSON-Datenobjekt zu einer tatsächlichen Swift-Klasse oder -Struktur zu gelangen. Dies wird Dekodierung genannt, weil die JSON-Daten in ein Format dekodiert werden, das Swift versteht. Es funktioniert auch in die andere Richtung: Kodierung von Swift-Objekten als JSON.

Das Codable-Protokoll in Swift ist eigentlich ein Alias der Decodable– und Encodable-Protokolle. Da man oft Kodierung und Dekodierung zusammen verwendet, verwendet man das Codable-Protokoll, um beide Protokolle in einem Rutsch zu erhalten.

Das Herzstück des Kodierungs-/Dekodierungsworkflows ist das Codable-Protokoll von Swift. Finden wir als Nächstes heraus, wie es funktioniert!

Das Codable-Protokoll erklärt

Die Verwendung von JSON vor Swift 4 war ein ziemliches Ärgernis. Man musste das JSON selbst mit JSONSerialization serialisieren und dann jede Eigenschaft des JSON in den richtigen Swift-Typ umwandeln.

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

Das obige Snippet greift nur einen yield-Wert aus dem JSON und wandelt ihn in Int um. Das ist extrem langatmig, und es ist schwer, auf mögliche Fehler und Typdiskrepanzen zu reagieren. Auch wenn es funktioniert, ist es nicht ideal.

Bibliotheken wie SwiftyJSON machen die Arbeit mit JSON viel einfacher, aber Sie müssen die JSON-Daten immer noch auf die entsprechenden Swift-Objekte und -Eigenschaften abbilden.

Mit Swift 4 und später können Sie stattdessen das Codable-Protokoll verwenden. Ihre Swift-Struktur oder -Klasse muss lediglich das Codable-Protokoll übernehmen, und Sie erhalten die JSON-Kodierung und -Dekodierung sofort und kostenlos.

Das Codable-Protokoll ist eine Zusammensetzung aus zwei Protokollen, Decodable und Encodable. Beide Protokolle sind ziemlich minimal; sie definieren nur die Funktionen init(from: Decoder) bzw. encode(to: Encoder). Mit anderen Worten, diese Funktionen bedeuten, dass ein Typ, um „decodierbar“ oder „codierbar“ zu sein, „von etwas decodieren“ und „zu etwas codieren“ muss.

Die wahre Magie von Codable geschieht mit den Protokollen Decoder und Encoder. Diese Protokolle werden von den Komponenten übernommen, die verschiedene Datenformate, wie JSON, kodieren/dekodieren. In Swift haben wir ein paar -Kodierer:

• PropertyListEncoder und PropertyListDecoder für .plist-Eigenschaftslisten
• JSONEncoder und JSONDecoder für JSON – das sind wir!
• NSKeyedArchiver kann mit Codable, über PropertyListEncoder, Data und NSCoding

arbeiten. Die Klassen JSONDecoder und JSONEncoder verwenden die Decoder und Encoder Protokolle, um die Funktionalität zum Dekodieren/Kodieren von JSON bereitzustellen. Das bedeutet auch, dass Sie Ihren eigenen benutzerdefinierten Encoder/Decoder für Codable schreiben können, vorausgesetzt, Sie übernehmen die Decoder– und Encoder-Protokolle!

Arbeiten mit Codable

Werfen wir einen Blick auf ein Beispiel. Wir werden einige JSON-Daten auf eine Swift-Struktur abbilden. Im Wesentlichen dekodieren wir die JSON-Daten in ein tatsächliches Swift-Objekt.

Zuerst erstellen wir eine Struktur namens User. Etwa so:

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

Die User-Struktur hat drei einfache Eigenschaften vom Typ String und entspricht dem Codable-Protokoll.

Dann schreiben wir ein wenig JSON. Dies ist das JSON, mit dem wir arbeiten werden:

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

JSON-Daten kommen normalerweise als Antwort auf eine Webservice-Anfrage oder über eine .json-Datei in Ihre Anwendung, aber für dieses Beispiel setzen wir das JSON einfach in eine String-Datei. Etwa so:

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

Als nächstes dekodieren wir das JSON und wandeln es in ein User-Objekt um. So geht’s:

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

So geht’s:

• Zunächst wird jsonString in ein Data-Objekt umgewandelt, indem die data(using:)-Funktion für den String aufgerufen wird. Dies ist ein notwendiger Zwischenschritt.
• Dann erstellen Sie ein JSONDecoder-Objekt und rufen sofort die Funktion decode(_:from:) dafür auf. Diese verwandelt das jsonData in ein Objekt des Typs User, indem sie das JSON dekodiert. Der User.self-Typ wird als Parameter übergeben.
• Schließlich geben Sie den Nachnamen des Benutzers mit print(user.last_name) aus. Dieser user-Wert hat User als Typ, ist also ein echtes Swift-Objekt!

Einfach, oder? Sie haben das JSON-Objekt im Wesentlichen auf eine Swift-Struktur „gemappt“ und das JSON-Format in ein natives Objekt dekodiert, mit dem Swift arbeiten kann.

Im obigen Code ignorieren wir alle Fehler, die durch decode(_:from:) mit try! ausgelöst werden. In Ihrem eigenen Code müssen Sie Fehler mit einem do-try-catch-Block behandeln. Ein Fehler, der ausgelöst werden kann, entsteht zum Beispiel durch die Bereitstellung von ungültigem JSON.

Das User.self ist ein Metatyp, ein Verweis auf den Typ User selbst. Wir teilen dem Decoder mit, dass wir die Daten mit dem User struct dekodieren wollen, indem wir ihm einen Verweis auf diesen Typ zur Verfügung stellen.

Dekodieren von JSON in Swift-Objekte mit Codable

Schauen wir uns noch einmal das Beispiel aus dem vorherigen Abschnitt an und erweitern es. Hier ist das JSON, mit dem wir arbeiten:

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

Das wandeln wir dann in ein Data-Objekt um. Etwa so:

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

Dies ist ein notwendiger Zwischenschritt. Anstatt JSON als Zeichenkette darzustellen, speichern wir JSON nun als natives Data-Objekt. Die Zeichenkodierung, die wir für diese Zeichenfolge verwenden, ist UTF8.

Wenn Sie genau hinsehen, werden Sie sehen, dass der obige Code Force Unwrapping verwendet, um mit dem optionalen Rückgabewert von data(using:) zu arbeiten. Lassen Sie uns diese Option eleganter auspacken!

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

Mit dem obigen Code können wir auf Fehler reagieren, wenn data(using:) nil zurückgibt. Man könnte zum Beispiel eine Fehlermeldung anzeigen oder die Aufgabe stillschweigend scheitern lassen und Diagnoseinformationen in einem Protokoll speichern.

Als nächstes erstellen wir ein neues JSONDecoder-Objekt. So:

let decoder = JSONDecoder()

Wir verwenden dann diesen Decoder, um die JSON-Daten zu dekodieren. So geht’s:

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

Die Funktion decode(_:from:) kann jedoch Fehler auslösen. Der obige Code stürzt ab, wenn das passiert. Auch hier wollen wir auf alle Fehler reagieren, die auftreten können. Etwa so:

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

Und der gesamte Codeblock sieht jetzt wie folgt aus. Sehen Sie, wie sich das unterscheidet?

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

Arbeiten mit CodingKeys

Was ist, wenn unsere JSON-Eigenschaften, wie first_name und/oder firstName, anders sind als die Swift-Struktureigenschaften? Hier kommt CodingKeys ins Spiel.

Jede Klasse oder Struktur, die mit Codable konform ist, kann eine spezielle verschachtelte Aufzählung namens CodingKeys deklarieren. Sie wird verwendet, um Eigenschaften zu definieren, die kodiert und dekodiert werden sollen, einschließlich ihrer Namen.

Schauen wir uns ein Beispiel an. In der User Struktur unten haben wir die Eigenschaftsnamen von snake_case in camelCase geändert. Zum Beispiel heißt der Schlüssel first_name jetzt 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 }}

Wenn Sie die obige Struktur mit den Beispielen in den vorherigen Abschnitten verwenden, werden Sie sehen, dass Sie ein User-Objekt mit den neuen Eigenschaftsnamen verwenden können. Etwa so:

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

Die CodingKeys-Aufzählung ordnet ihre Fälle den Eigenschaften zu und verwendet die Zeichenfolgenwerte, um die richtigen Eigenschaftsnamen in den JSON-Daten auszuwählen. Der Fall in der Aufzählung ist der Name der Eigenschaft, die Sie in der Struktur verwenden möchten, und der Wert ist der Name des Schlüssels in den JSON-Daten.

Kodierung von Swift-Objekten als JSON mit Codable

So weit haben wir uns auf die Dekodierung von JSON-Daten in Swift-Objekte konzentriert. Wie sieht es mit dem umgekehrten Weg aus? Können wir auch Objekte als JSON kodieren? Ja, warum nicht!

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)

Und die Ausgabe lautet:

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

Was passiert hier?

• Zuerst erstellen Sie ein User Objekt und weisen seinen Eigenschaften einige Werte zu
• Dann verwenden Sie encode(_:), um das user Objekt in ein JSON Data Objekt zu kodieren
• Schließlich, konvertiert man das Data-Objekt in String und druckt es aus

Wenn man genau hinsieht, sieht man, dass die Kodierung denselben Schritten folgt wie die Dekodierung, nur in umgekehrter Reihenfolge. Vom Swift-Objekt geht es durch den Decoder, was zu einer JSON-Zeichenkette führt.

Können wir das Beispiel wie zuvor erweitern, um mit Fehlern umzugehen? Ja! Etwa so:

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

Im obigen Beispiel verwenden wir auch die outputFormatting-Eigenschaft des Encoders, um die JSON-Daten „hübsch zu machen“. Dabei werden Leerzeichen, Tabulatoren und Zeilenumbrüche hinzugefügt, um die JSON-Zeichenfolge besser lesbar zu machen. Etwa so:

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

Gut!

Arbeiten mit verschachtelten Arrays und Codable

Bis jetzt haben wir mit einfachen JSON-Objekten gearbeitet – nur eine Klasse mit ein paar Eigenschaften. Aber was ist, wenn die Daten, mit denen Sie arbeiten, komplexer sind?

Zum Beispiel sind die JSON-Daten, die Sie von einem Twitter- oder Facebook-Webservice zurückbekommen, oft verschachtelt. Das heißt, die Daten, auf die Sie zugreifen möchten, sind in 2-3 Ebenen von JSON-Arrays und -Wörterbüchern vergraben. Was nun?

Schauen wir uns zunächst ein einfaches Beispiel an. Hier ist die Swift-Struktur, mit der wir arbeiten werden:

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

Dann sind hier die JSON-Daten, die wir dekodieren wollen:

let jsonString = """"""

Wenn Sie genau hinschauen, sehen Sie, dass die Daten, die wir brauchen, als Array gespeichert sind. Das JSON ist nicht ein einfaches Objekt, sondern ein Array mit 3 User Objekten. Dass es sich um ein Array von Objekten handelt, erkennen wir an den eckigen Klammern (Array) und den verschnörkelten Klammern { } (Objekt). Mehrere Elemente werden immer durch Kommas getrennt.

Wie können wir diese User Objekte entschlüsseln? So geht’s:

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

Der obige Codeschnipsel ist dem, was Sie bisher gesehen haben, sehr ähnlich, aber es gibt einen wichtigen Unterschied. Sehen Sie den Typ, den wir der Funktion decode(_:from:) übergeben? Der Typ ist (mit .self), oder „array of User objects“. Anstatt mit einem User-Objekt zu arbeiten, wollen wir einen Haufen von ihnen dekodieren, und das wird mit dem Typ -Array bezeichnet.

Als Nächstes werden wir besprechen, wie Sie mit komplexeren verschachtelten Typen arbeiten können. Nehmen wir zum Beispiel an, dass das Array von User-Objekten in einem JSON-Dictionary verschachtelt ist. Etwa so:

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

Im obigen JSON-Schnipsel ist das oberste Element ein Wörterbuch (oder „Objekt“). Es hat nur ein Schlüssel-Wert-Paar: ein users-Array. Die Daten, die wir brauchen, befinden sich in diesem Array. Wie kommen wir an sie heran?

Es ist wichtig, dass wir unseren Ansatz nicht zu kompliziert gestalten. Man könnte meinen, dass man ein fortgeschrittenes JSON-Parsing braucht, aber wie sich herausstellt, können wir auch Swift-Strukturen verschachteln. Wir werden das gesamte JSON als struct beschreiben, mit dem User struct darin.

Hier, sehen Sie sich das an:

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

Hier ist, was los ist:

• Das JSON-Wörterbuch auf oberster Ebene entspricht dem Typ Response. Genau wie zuvor entspricht dieser Typ Codable, um JSON-Kodierung und -Dekodierung zu unterstützen.
• Innerhalb dieser Struktur haben wir eine weitere Struktur namens User definiert. Dies ist genau derselbe Typ, den wir zuvor verwendet haben. Dieses struct ist „verschachtelt“.
• Das Response struct hat eine Eigenschaft namens users vom Typ , oder ein Array von User-Objekten.

Das Tolle daran ist, dass die Datenstrukturen von JSON und Swift semantisch genau gleich sind. Sie verwenden nur eine andere Syntax. Wir haben ein verschachteltes Array innerhalb des obersten Wörterbuchs definiert, genau wie die Response Struktur eine verschachtelte User Struktur und users Eigenschaft darin hat.

Es ist jetzt ein Kinderspiel, es zum Laufen zu bringen. Sieh dir das an:

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

Siehst du, wie wir den Response-Typ verwenden, um das JSON zu dekodieren und dann eine Schleife über die response.users-Eigenschaft ziehen? Überprüfen Sie das mit der Response-Struktur und dem JSON. Wir wählen das users-Schlüssel-Wert-Paar im Top-Level-Dictionary aus und ordnen die Objekte darin User-Objekten zu. Toll!

Weitere Lektüre

Und das war’s dann auch schon! Ihr wisst jetzt Bescheid:

• Wie man Codable verwendet, um Objekte zu erstellen, die kodiert und dekodiert werden können
• Wie man JSONDecoder und JSONEncoder verwendet, um JSON-Objekte und ihre Swift-Gegenstücke zu kodieren und zu dekodieren
• Wofür man kodiert und dekodiert, und warum es in der täglichen iOS-Entwicklung wichtig ist
• Wie man mit komplexeren JSON-Daten arbeitet und wie man verschachtelte Typen verwendet

Wollen Sie mehr erfahren? Schauen Sie sich diese Ressourcen an:

• Arrays, Dictionaries und Structs
• Mit SwiftyJSON in Swift mit JSON arbeiten
• Einführung in die objektorientierte Programmierung in Swift
• Wie man: Ein Element in einem Array in Swift finden
• Wie man Apples Entwicklerdokumentation gewinnbringend einsetzt
• Wie man Strings mit regulären Ausdrücken in Swift findet
• Warum App Architecture Matters
• Strings in Swift Explained
• Working with Files on iOS with Swift
• Storing Data with NSCoding and NSKeyedArchiver