How to work with JSON in Swift?

1

import Foundation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

let jsonString = """
{
    "name": "John Doe",
    "age": 30,
    "city": "New York"
}
"""

// Convert the JSON string to Data
guard let jsonData = jsonString.data(using: .utf8) else {
    fatalError("Invalid JSON string")
}

// Convert JSON Data to a Swift object
do {
    let jsonObject = try JSONSerialization.jsonObject(with: jsonData, options: [])
    
    if let jsonDict = jsonObject as? [String: Any] {
        let name = jsonDict["name"] as? String
        let age = jsonDict["age"] as? Int
        let city = jsonDict["city"] as? String
        
        // Access the parsed values
        print("Name: \(name ?? "")")
        print("Age: \(age ?? 0)")
        print("City: \(city ?? "")")
    }
} catch {
    print("Error parsing JSON: \(error)")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

let personDict: [String: Any] = [
    "name": "John Doe",
    "age": 30,
    "city": "New York"
]

// Convert Swift object to JSON Data
do {
    let jsonData = try JSONSerialization.data(withJSONObject: personDict, options: .prettyPrinted)
    
    // Convert JSON Data to String
    if let jsonString = String(data: jsonData, encoding: .utf8) {
        print("JSON String: \(jsonString)")
    }
} catch {
    print("Error converting to JSON: \(error)")
}

1
2
3
4

struct MyObject: Codable {
    let property1: String
    let property2: Int
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

let myObject = MyObject(property1: "Value 1", property2: 123)

let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted  // Optional formatting to make the JSON output more readable

do {
    let jsonData = try encoder.encode(myObject)
    let jsonString = String(data: jsonData, encoding: .utf8)
    print(jsonString ?? "")
} catch {
    print("Encoding failed: \(error)")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

struct Person: Codable {
    let name: String
    let age: Int
    let address: Address
}

struct Address: Codable {
    let street: String
    let city: String
    // Other properties
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

let jsonData = """
{
    "name": "John Doe",
    "age": 30,
    "address": {
        "street": "123 Main St",
        "city": "Los Angeles"
    }
}
""".data(using: .utf8)!

let decoder = JSONDecoder()
do {
    let person = try decoder.decode(Person.self, from: jsonData)
    print(person.name) // John Doe
    print(person.address.city) // Los Angeles
} catch {
    print("Error decoding JSON: \(error)")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

let person = Person(name: "John Doe", age: 30, address: Address(street: "123 Main St", city: "Los Angeles"))

let encoder = JSONEncoder()
do {
    let jsonData = try encoder.encode(person)
    let jsonString = String(data: jsonData, encoding: .utf8)
    print(jsonString) // {"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Los Angeles"}}
} catch {
    print("Error encoding to JSON: \(error)")
}

1
2
3
4

enum JSONError: Error {
    case invalidData
    case decodingFailed
}

1
2
3
4

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func decodeJSON(from data: Data) throws -> Person {
    let decoder = JSONDecoder()
    decoder.keyDecodingStrategy = .convertFromSnakeCase
    do {
        let person = try decoder.decode(Person.self, from: data)
        return person
    } catch {
        throw JSONError.decodingFailed
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func encodeJSON(person: Person) throws -> Data {
    let encoder = JSONEncoder()
    encoder.keyEncodingStrategy = .convertToSnakeCase
    do {
        let data = try encoder.encode(person)
        return data
    } catch {
        throw JSONError.encodingFailed
    }
}