Introduction

In Swift 4, converting a JSON string into something useful usually means one of two things: decoding it into a typed Swift model with Codable, or parsing it into a generic dictionary or array with JSONSerialization. The best choice depends on whether you know the structure ahead of time.

Convert the String to Data First

Both approaches begin by turning the JSON string into Data.

1import Foundation
2
3let jsonString = """
4{
5  "id": 42,
6  "name": "Ada"
7}
8"""
9
10guard let data = jsonString.data(using: .utf8) else {
11    fatalError("Invalid UTF-8 string")
12}

Without that conversion, the Foundation JSON APIs cannot parse the content.

Use Codable for Known Structure

If you know what fields the JSON contains, decode into a typed model.

1import Foundation
2
3struct User: Codable {
4    let id: Int
5    let name: String
6}
7
8let decoder = JSONDecoder()
9let user = try decoder.decode(User.self, from: data)
10print(user.name)

This is usually the best Swift 4 answer because it is type-safe and easier to maintain than manual dictionary access.

Use JSONSerialization for Dynamic JSON

If the schema is unknown or highly dynamic, parse into Foundation containers.

1import Foundation
2
3if let jsonObject = try JSONSerialization.jsonObject(with: data) as? [String: Any] {
4    print(jsonObject["name"] ?? "missing")
5}

This is more flexible, but you lose compile-time type guarantees and end up doing more runtime casting.

Handle Arrays the Same Way

JSON strings do not always represent objects. Sometimes the top-level structure is an array.

1let jsonArrayString = """
2[
3  { "id": 1, "name": "Ada" },
4  { "id": 2, "name": "Linus" }
5]
6"""
7
8let arrayData = jsonArrayString.data(using: .utf8)!
9let users = try JSONDecoder().decode([User].self, from: arrayData)
10print(users.count)

The decoding target must match the JSON structure exactly.

Add Error Handling Around Parsing

Bad JSON, wrong types, or missing fields should be treated as normal failure cases.

1do {
2    let user = try JSONDecoder().decode(User.self, from: data)
3    print(user)
4} catch {
5    print("Failed to decode JSON: \\(error)")
6}

That is especially important for network responses where malformed payloads and version drift are real possibilities.

Prefer Models Over Loose Dictionaries

It is tempting to parse everything into [String: Any], but that often creates messy code downstream. If the payload shape is stable enough to describe as a struct, Codable is almost always the cleaner design.

Nested JSON Still Follows the Same Pattern

Whether the payload is simple or nested, the rule stays the same: describe the shape in Swift structs when possible and let JSONDecoder do the mapping. The complexity belongs in the model, not in repeated manual dictionary extraction.

That is one of the biggest practical wins of Swift 4 JSON handling compared with older manual parsing styles.

It reduces manual casting mistakes.

And cleanup work.

Common Pitfalls

• Forgetting to convert the string to Data before decoding.
• Decoding into the wrong top-level type, such as an object when the JSON is really an array.
• Using [String: Any] everywhere even when the schema is known.
• Assuming all values are present and of the expected type.
• Swallowing decoding errors and making JSON problems hard to diagnose.

Summary

• Convert the JSON string to Data first.
• Use Codable when the JSON structure is known.
• Use JSONSerialization when the JSON shape is dynamic.
• Match the decode target to the real top-level JSON structure.
• Keep error handling explicit so bad payloads fail clearly.