Encoding and Decoding JSON in Swift

JSON (JavaScript Object Notation) is a lightweight data interchange format that is widely used for representing data structures. JSON has become the de facto standard for exchanging data between the client and server in modern web applications. In Swift, encoding and decoding JSON is a common task that developers encounter when working with web APIs or handling data serialization. In this article, we will explore how to encode and decode JSON in Swift.

JSON Encoding

Encoding JSON in Swift involves converting Swift objects, such as structs or classes, into JSON data. This process is also known as serialization. The Encoder protocol and its concrete implementations provide the tools necessary for encoding Swift objects into JSON. The most commonly used encoder in Swift is JSONEncoder.

Let’s say we have a Person struct that represents a person’s information:

struct Person: Codable {
    let name: String
    let age: Int
    let email: String
}

To encode an instance of the Person struct to JSON, we can use JSONEncoder as follows:

let person = Person(name: "John Doe", age: 30, email: "john.doe@example.com")

do {
    let encoder = JSONEncoder()
    let jsonData = try encoder.encode(person)
    print(String(data: jsonData, encoding: .utf8)!)
} catch {
    print("Error encoding person: \(error)")
}

In the above example, we create an instance of Person with some sample data. We then create an instance of JSONEncoder. The encode(_:) method of JSONEncoder is used to encode the person object into JSON data. Finally, we print the JSON data as a string.

When you run the above code, you will see the following output:

{
  "name" : "John Doe",
  "age" : 30,
  "email" : "john.doe@example.com"
}

Customizing the Encoding Process

By default, JSONEncoder uses the property names of your struct or class and encodes them directly to JSON key-value pairs. However, you may want to customize the encoding process by changing the property names or omitting certain properties from the encoded JSON.

You can use the CodingKeys enum to customize the encoding process. Let’s consider an example where we want to change the property names in the encoded JSON:

struct Person: Codable {
    let personName: String
    let personAge: Int
    let personEmail: String
    
    private enum CodingKeys: String, CodingKey {
        case personName = "name"
        case personAge = "age"
        case personEmail = "email"
    }
}

In the above code, we added a nested enum called CodingKeys to our Person struct. Each case in the enum represents a property we want to include in the encoded JSON, and we specify the key under which the property should be encoded. In this case, we changed the property names to start with the word „person“.

After making this change, if we encode a Person instance using the updated struct definition, the generated JSON will have the modified property names:

{
  "name" : "John Doe",
  "age" : 30,
  "email" : "john.doe@example.com"
}

JSON Decoding

Decoding JSON in Swift is the process of converting JSON data into Swift objects. This process is also known as deserialization. The Decoder protocol and its concrete implementations provide the tools necessary for decoding JSON into Swift objects. The most commonly used decoder in Swift is JSONDecoder.

Let’s say we have a JSON string representation of a Person object:

let jsonString = """
    {
        "name": "Jane Smith",
        "age": 25,
        "email": "jane.smith@example.com"
    }
    """

To decode the JSON string into an instance of the Person struct, we can use JSONDecoder as follows:

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

do {
    let decoder = JSONDecoder()
    let person = try decoder.decode(Person.self, from: jsonData)
    print(person)
} catch {
    print("Error decoding person: \(error)")
}

In the above example, we convert the JSON string to raw data using data(using:). We then use JSONDecoder to decode the JSON data into a Person object. Finally, we print the decoded Person object.

When you run the above code, you will see the following output:

Person(personName: "Jane Smith", personAge: 25, personEmail: "jane.smith@example.com")

Error Handling

When decoding JSON, it’s important to handle potential errors that may occur. The decode(_:from:) method throws an error if the decoding process fails. Common errors include data mismatch, missing required properties, or invalid JSON format.

In the previous example, if we modify the JSON string to remove the „name“ field, we will encounter a decoding error:

let jsonString = """
    {
        "age": 25,
        "email": "jane.smith@example.com"
    }
    """

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

do {
    let decoder = JSONDecoder()
    let person = try decoder.decode(Person.self, from: jsonData)
    print(person)
} catch {
    print("Error decoding person: \(error)")
}

When you run the above code, it will print the following error message:

Error decoding person: keyNotFound(CodingKeys(stringValue: "name", intValue: nil), Swift.DecodingError.Context(codingPath: [], debugDescription: "No value associated with key CodingKeys(stringValue: \"name\", intValue: nil) (\"name\").", underlyingError: nil))

Customizing the Decoding Process

Similar to encoding, you can customize the decoding process in Swift. The Codable protocol provides several ways to handle custom decoding logic.

Let’s say we have a Person struct that includes an optional phoneNumber property:

struct Person: Codable {
    let name: String
    let age: Int
    let email: String
    let phoneNumber: String?
}

By default, if the JSON does not contain a value for the phoneNumber property or the value is null, the resulting phoneNumber property in the Person instance will be nil. However, we may want to provide a default value if the phoneNumber is missing or null.

To achieve this, we can implement the init(from:) method in our Person struct:

struct Person: Codable {
    let name: String
    let age: Int
    let email: String
    let phoneNumber: String?
    
    private enum CodingKeys: String, CodingKey {
        case name, age, email, phoneNumber
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decode(String.self, forKey: .name)
        age = try container.decode(Int.self, forKey: .age)
        email = try container.decode(String.self, forKey: .email)
        phoneNumber = try container.decodeIfPresent(String.self, forKey: .phoneNumber) ?? "N/A"
    }
}

In the code above, we implement the init(from:) method and use the decodeIfPresent(_:forKey:) method to decode the phoneNumber property. If the JSON does not contain a value for phoneNumber or it is null, we provide a default value of „N/A“.

Now, if we decode JSON data that does not include a value for phoneNumber, the resulting phoneNumber property in the Person instance will be set to „N/A“:

let jsonString = """
    {
        "name": "Jane Smith",
        "age": 25,
        "email": "jane.smith@example.com"
    }
    """

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

do {
    let decoder = JSONDecoder()
    let person = try decoder.decode(Person.self, from: jsonData)
    print(person)
} catch {
    print("Error decoding person: \(error)")
}

When you run the above code, you will see the following output:

Person(name: "Jane Smith", age: 25, email: "jane.smith@example.com", phoneNumber: "N/A")

Conclusion

In this article, we explored how to encode and decode JSON in Swift. We learned how to use the JSONEncoder and JSONDecoder classes to convert Swift objects to JSON and JSON to Swift objects, respectively. We also learned how to customize the encoding and decoding process by using the CodingKeys enum and implementing the init(from:) method. By mastering JSON encoding and decoding in Swift, you will be able to seamlessly work with JSON data in your applications and APIs.