Swift 5 (Xcode 11 Betas 5 & 6) - How to write to a JSON file?

Question

This question has been asked quite a few times over the years, but it has changed again in Swift 5, particularly in the last two betas.

Reading a JSON file seems to be quite simple:

func readJSONFileData(_ fileName: String) -> Array<Dictionary<String, Any>> {

    var resultArr: Array<Dictionary<String, Any>> = []

    if let url = Bundle.main.url(forResource: "file", withExtension: "json") {

        if let data = try? Data(contentsOf: url) {

            print("Data raw: ", data)

            if let json = try? (JSONSerialization.jsonObject(with: data, options: []) as! NSArray) {

                print("JSON: ", json)

                if let arr = json as? Array<Any> {

                    print("Array: ", arr)

                    resultArr = arr.map { $0 as! Dictionary<String, Any> }

                }

            }

        }

    }

    return resultArr

}

But writing is incredibly difficult, and all of the previous methods found on this site have failed in Swift 5 on Xcode 11 betas 5 and 6.

How can I write data to a JSON file in Swift 5?

I tried these approaches:

• How to save an array as a json file in Swift?
• Writing JSON file programmatically swift
• read/write local json file swift 4

There weren't any errors except for deprecation warnings, and when I fixed those, it simply didn't work.

Answer 1

Let’s assume for a second that you had some random collection (either arrays or dictionaries or some nested combination thereof):

let dictionary: [String: Any] = ["bar": "qux", "baz": 42]

Then you could save it as JSON in the “Application Support” directory like so:

do {
    let fileURL = try FileManager.default
        .url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
        .appendingPathComponent("example.json")

    try JSONSerialization.data(withJSONObject: dictionary)
        .write(to: fileURL)
} catch {
    print(error)
}

For rationale why we now use “Application Support” directory rather than the “Documents” folder, see the iOS Storage Best Practices video or refer to the File System Programming Guide. But, regardless, we use those folders, not the Application’s “bundle” folder, which is read only.

And to read that JSON file:

do {
    let fileURL = try FileManager.default
        .url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
        .appendingPathComponent("example.json")

    let data = try Data(contentsOf: fileURL)
    let dictionary = try JSONSerialization.jsonObject(with: data)
    print(dictionary)
} catch {
    print(error)
}

---

That having been said, we generally prefer to use strongly typed custom types rather than random dictionaries where the burden falls upon the programmer to make sure there aren’t typos in the key names. Anyway, we make these custom struct or class types conform to Codable:

struct Foo: Codable {
    let bar: String
    let baz: Int
}

Then we’d use JSONEncoder rather than the older JSONSerialization:

let foo = Foo(bar: "qux", baz: 42)
do {
    let fileURL = try FileManager.default
        .url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
        .appendingPathComponent("example.json")

    try JSONEncoder().encode(foo)
        .write(to: fileURL)
} catch {
    print(error)
}

And to read that JSON file:

do {
    let fileURL = try FileManager.default
        .url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
        .appendingPathComponent("example.json")

    let data = try Data(contentsOf: fileURL)
    let foo = try JSONDecoder().decode(Foo.self, from: data)
    print(foo)
} catch {
    print(error)
}

For more information about preparing JSON from custom types, see the Encoding and Decoding Custom Types article or the Using JSON with Custom Types sample code.

Answer 2

In case anyone is working with custom objects (as I am) and want a more 'all around' function with generics

Save File To Manager

func saveJSON<T: Codable>(named: String, object: T) {
    do {
        let fileURL = try FileManager.default
            .url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
            .appendingPathComponent(named)
        let encoder = try JSONEncoder().encode(object)

        try encoder.write(to: fileURL)
    } catch {
        print("JSONSave error of \(error)")
    }
}

Read File From Manager

func readJSON<T: Codable>(named: String, _ object: T.Type) -> T? {
     do {
         let fileURL = try FileManager.default
                .url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
                .appendingPathComponent(named)
         let data = try Data(contentsOf: fileURL)

         let object = try JSONDecoder().decode(T.self, from: data)

        return object
    } catch {
        return nil
    }
}

Answer 3

Answering the question:

Let's just say I have some JSON data - how would I write it to file.json? It's in my project directory - is this writable? And if not, how would I make it writable?

Assuming that "some JSON" means an array of dictionaries as [<String, String>], here is a simple example of how you could do it:

Consider that we have the following array that we need to write it as JSON to a file:

let array = [["Greeting":"Hello", "id": "101", "fruit": "banana"],
             ["Greeting":"Hola", "id": "102", "fruit": "tomato"],
             ["Greeting":"Salam", "id": "103", "fruit": "Grape"]]

The first thing to do is to convert it to a JSON (as Data instance). There is more that one option to do it, let's use JSONSerialization one:

do {
    let data = try JSONSerialization.data(withJSONObject: array, options: [])
    if let dataString = String(data: data, encoding: .utf8) {
        print(dataString)
    }
} catch {
    print(error)
}

At this point, you should see on the console:

[{"Greeting":"Hello","fruit":"banana","id":"101"},{"fruit":"tomato","Greeting":"Hola","id":"102"},{"fruit":"Grape","Greeting":"Salam","id":"103"}]

which is our data formatted as valid JSON.

Next, we need to write it on the file. In order to do it, we'll use FileManager as:

do {
    let data = try JSONSerialization.data(withJSONObject: array, options: [])
    if let documentDirectoryUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
        let fileUrl = documentDirectoryUrl.appendingPathComponent("MyFile.json")
        try data.write(to: fileUrl)
    }
} catch {
    print(error)
}

Note that the file should exist in the documents directory; In the above example its name should be "MyFile.json".