Reading in a JSON File Using Swift

Question

I'm really struggling with trying to read a JSON file into Swift so I can play around with it. I've spent the best part of 2 days re-searching and trying different methods but no luck as of yet so I have signed up to StackOverFlow to see if anyone can point me in the right direction.....

My JSON file is called test.json and contains the following:

{
  "person":[
     {
       "name": "Bob",
       "age": "16",
       "employed": "No"
     },
     {
       "name": "Vinny",
       "age": "56",
       "employed": "Yes"
     }
  ]
}

The file is stored in the documents directly and I access it using the following code:

let file = "test.json"
let dirs : String[] = NSSearchPathForDirectoriesInDomains(
                                                          NSSearchpathDirectory.DocumentDirectory,
                                                          NSSearchPathDomainMask.AllDomainMask,
                                                          true) as String[]

if (dirs != nil) {
    let directories: String[] = dirs
    let dir = directories[0]
    let path = dir.stringByAppendingPathComponent(file)
}

var jsonData = NSData(contentsOfFile:path, options: nil, error: nil)
println("jsonData \(jsonData)" // This prints what looks to be JSON encoded data.

var jsonDict = NSJSONSerialization.JSONObjectWithData(jsonData, options: nil, error: nil) as? NSDictionary

println("jsonDict \(jsonDict)") - This prints nil.....

If anyone can just give me a push in the right direction on how I can de-serialize the JSON file and put it in an accessible Swift object I will be eternally grateful!

Kind Regards,

Krivvenz.

Please post actual, compilable code. As it is now, path is visible only in if scope, and unresolved when you use it in NSData(contentsOfFile, options, error); you also have typos in enum names. — Kreiri
– Kreiri, Commented Jun 25, 2014 at 14:17
My API is fully updated for Swift 3: github.com/borchero/WebParsing — borchero
– borchero, Commented Sep 29, 2016 at 20:23
this is key -> "values": "%LOAD VALUE FROM tmclass.json file%" and i need to parse another JSON from file then how i can achieve this in SWIFT ? — Mayur Shinde
– Mayur Shinde, Commented Sep 17, 2019 at 13:34

Nicolas Miari · Accepted Answer · 2018-03-26 06:32:02Z

380

Follow the below code :

if let path = NSBundle.mainBundle().pathForResource("test", ofType: "json")
{
    if let jsonData = NSData(contentsOfFile: path, options: .DataReadingMappedIfSafe, error: nil)
    {
        if let jsonResult: NSDictionary = NSJSONSerialization.JSONObjectWithData(jsonData, options: NSJSONReadingOptions.MutableContainers, error: nil) as? NSDictionary
        {
            if let persons : NSArray = jsonResult["person"] as? NSArray
            {
                // Do stuff
            }
        }
     }
}

The array "persons" will contain all data for key person. Iterate throughs to fetch it.

Swift 4.0:

if let path = Bundle.main.path(forResource: "test", ofType: "json") {
    do {
          let data = try Data(contentsOf: URL(fileURLWithPath: path), options: .mappedIfSafe)
          let jsonResult = try JSONSerialization.jsonObject(with: data, options: .mutableLeaves)
          if let jsonResult = jsonResult as? Dictionary<String, AnyObject>, let person = jsonResult["person"] as? [Any] {
                    // do stuff
          }
      } catch {
           // handle error
      }
}

edited Mar 26, 2018 at 6:32

Nicolas Miari

16.3k8 gold badges89 silver badges195 bronze badges

answered Jun 25, 2014 at 14:10

iOS

5,4805 gold badges26 silver badges25 bronze badges

Sign up to request clarification or add additional context in comments.

12 Comments

Martin R Over a year ago

It would be more helpful if you explained why/how this solves the problem described in the question, instead of just presenting a bunch of code.

Krivvenz Over a year ago

Hi Abhishek - Thanks for your answer but it still doesn't work. That causes the application to crash with the below error: 2014-06-25 16:02:04.146 H & S Capture[4937:131932] *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '*** -[_NSPlaceholderData initWithContentsOfFile:options:error:]: nil file argument' *** First throw call stack: Any ideas on why this is? For the jsonData options: I put (path, options: NSDataReadingOptions.DataReadingMappedIfSafe, error: nil)

tong Over a year ago

"let jsonData = NSData(contentsOfFile:path!)" instead of "let jsonData = NSData.dataWithContentsOfFile(path, options: .DataReadingMappedIfSafe, error: nil)"

Zonily Jame Over a year ago

It's better to use guard else statements here instead of this pyramid of doom though.

Akash Bhardwaj Over a year ago

Don't forget to add the file to your bundle. stackoverflow.com/questions/41775563/…

|

yarlg · Accepted Answer · 2021-06-09 09:59:01Z

221

Swift 4.x and 5.x using Decodable

struct ResponseData: Decodable {
    var person: [Person]
}
struct Person : Decodable {
    var name: String
    var age: String
    var employed: String
}

func loadJson(filename fileName: String) -> [Person]? {
    if let url = Bundle.main.url(forResource: fileName, withExtension: "json") {
        do {
            let data = try Data(contentsOf: url)
            let decoder = JSONDecoder()
            let jsonData = try decoder.decode(ResponseData.self, from: data)
            return jsonData.person
        } catch {
            print("error:\(error)")
        }
    }
    return nil
}

Swift 3

func loadJson(filename fileName: String) -> [String: AnyObject]? {
    if let url = Bundle.main.url(forResource: fileName, withExtension: "json") {
        do {
            let data = try Data(contentsOf: url)
            let object = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
            if let dictionary = object as? [String: AnyObject] {
                return dictionary
            }
        } catch {
            print("Error!! Unable to parse  \(fileName).json")
        }
    }
    return nil
}

edited Jun 9, 2021 at 9:59

answered Apr 24, 2016 at 19:38

yarlg

3,6613 gold badges22 silver badges20 bronze badges

1 Comment

some_id Over a year ago

This should be moved to the new documentation feature, or marked as the correct answer.

wm.p1us · Accepted Answer · 2018-03-13 07:52:32Z

158

If anyone is looking for SwiftyJSON Answer:
Update:
For Swift 3/4:

if let path = Bundle.main.path(forResource: "assets/test", ofType: "json") {
    do {
        let data = try Data(contentsOf: URL(fileURLWithPath: path), options: .alwaysMapped)
        let jsonObj = try JSON(data: data)
        print("jsonData:\(jsonObj)")
    } catch let error {
        print("parse error: \(error.localizedDescription)")
    }
} else {
    print("Invalid filename/path.")
}

edited Mar 13, 2018 at 7:52

wm.p1us

2,0592 gold badges27 silver badges39 bronze badges

answered Feb 21, 2015 at 10:02

Aks

8,3215 gold badges40 silver badges39 bronze badges

5 Comments

Paul Wand Over a year ago

this turned me onto swiftyJSON and carthage! thanks :)

Elazaron Over a year ago

i used it only to discover it lacks object mapping , i will try a different library next time

selva Over a year ago

To avoid copy paste error in swift 3: NSData and NSError became Data and Error.

crobicha Over a year ago

I tried a few different methods and this worked the best for me in Swift 3

vadian Over a year ago

Since MacOS 10.6 / iOS 4 (!) there is an API url(forResource in (NS)Bundle to avoid the extra step to create the URL

Gonzer · Accepted Answer · 2020-07-01 22:26:13Z

46

Swift 5.1, Xcode 11

You can use this:


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

func loadJson(fileName: String) -> Person? {
   let decoder = JSONDecoder()
   guard
        let url = Bundle.main.url(forResource: fileName, withExtension: "json"),
        let data = try? Data(contentsOf: url),
        let person = try? decoder.decode(Person.self, from: data)
   else {
        return nil
   }

   return person
}

edited Jul 1, 2020 at 22:26

answered May 12, 2020 at 3:15

Gonzer

5214 silver badges9 bronze badges

Comments

ben · Accepted Answer · 2016-11-14 07:51:28Z

Xcode 8 Swift 3 read json from file update:

    if let path = Bundle.main.path(forResource: "userDatabseFakeData", ofType: "json") {
        do {
            let jsonData = try NSData(contentsOfFile: path, options: NSData.ReadingOptions.mappedIfSafe)
            do {
                let jsonResult: NSDictionary = try JSONSerialization.jsonObject(with: jsonData as Data, options: JSONSerialization.ReadingOptions.mutableContainers) as! NSDictionary
                if let people : [NSDictionary] = jsonResult["person"] as? [NSDictionary] {
                    for person: NSDictionary in people {
                        for (name,value) in person {
                            print("\(name) , \(value)")
                        }
                    }
                }
            } catch {}
        } catch {}
    }

NeverwinterMoon · Accepted Answer · 2019-02-23 19:28:37Z

Simplifying the example provided by Peter Kreinz. Works with Swift 4.2.

The extension function:

extension Decodable {
  static func parse(jsonFile: String) -> Self? {
    guard let url = Bundle.main.url(forResource: jsonFile, withExtension: "json"),
          let data = try? Data(contentsOf: url),
          let output = try? JSONDecoder().decode(self, from: data)
        else {
      return nil
    }

    return output
  }
}

The example model:

struct Service: Decodable {
  let name: String
}

The example usage:

/// service.json
/// { "name": "Home & Garden" }

guard let output = Service.parse(jsonFile: "service") else {
// do something if parsing failed
 return
}

// use output if all good

The example will work with arrays, too:

/// services.json
/// [ { "name": "Home & Garden" } ]

guard let output = [Service].parse(jsonFile: "services") else {
// do something if parsing failed
 return
}

// use output if all good

Notice how we don't provide any unnecessary generics, thus we don't need to cast the result of parse.

Community · Accepted Answer · 2017-05-23 11:55:10Z

14

Updated names for Swift 3.0

Based on Abhishek's answer and Druva's answer

func loadJson(forFilename fileName: String) -> NSDictionary? {

    if let url = Bundle.main.url(forResource: fileName, withExtension: "json") {
        if let data = NSData(contentsOf: url) {
            do {
                let dictionary = try JSONSerialization.jsonObject(with: data as Data, options: .allowFragments) as? NSDictionary

                return dictionary
            } catch {
                print("Error!! Unable to parse  \(fileName).json")
            }
        }
        print("Error!! Unable to load  \(fileName).json")
    }

    return nil
}

edited May 23, 2017 at 11:55

CommunityBot

11 silver badge

answered Sep 22, 2016 at 21:17

Nick Graham

6056 silver badges12 bronze badges

Comments

kjm · Accepted Answer · 2015-11-15 12:47:54Z

Swift 2.1 answer (based on Abhishek's) :

    if let path = NSBundle.mainBundle().pathForResource("test", ofType: "json") {
        do {
            let jsonData = try NSData(contentsOfFile: path, options: NSDataReadingOptions.DataReadingMappedIfSafe)
            do {
                let jsonResult: NSDictionary = try NSJSONSerialization.JSONObjectWithData(jsonData, options: NSJSONReadingOptions.MutableContainers) as! NSDictionary
                if let people : [NSDictionary] = jsonResult["person"] as? [NSDictionary] {
                    for person: NSDictionary in people {
                        for (name,value) in person {
                            print("\(name) , \(value)")
                        }
                    }
                }
            } catch {}
        } catch {}
    }

Ashok R · Accepted Answer · 2016-11-13 03:29:38Z

Swift 3.0, Xcode 8, iOS 10

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

        do {
            let jsonData = try Data(contentsOf: path, options: .mappedIfSafe)
            do {
                if let jsonResult = try JSONSerialization.jsonObject(with: jsonData, options: JSONSerialization.ReadingOptions(rawValue: 0)) as? NSDictionary {
                    if let personArray = jsonResult.value(forKey: "person") as? NSArray {
                        for (_, element) in personArray.enumerated() {
                            if let element = element as? NSDictionary {
                                let name = element.value(forKey: "name") as! String
                                let age = element.value(forKey: "age") as! String
                                let employed = element.value(forKey: "employed") as! String
                                print("Name: \(name),  age: \(age), employed: \(employed)")
                            }
                        }
                    }
                }
            } catch let error as NSError {
                print("Error: \(error)")
            }
        } catch let error as NSError {
            print("Error: \(error)")
        }
    }

Output:

Name: Bob,  age: 16, employed: No
Name: Vinny,  age: 56, employed: Yes

Vasily Bodnarchuk · Accepted Answer · 2022-11-01 20:53:16Z

One more answer here???

Ok. Hold on! All of the answers before were about using JSONSerialization, or returns nil, or ignores errors.

What is the different

"My solution" (is is not really my, this is a mix of the solutions above) contains:

Modern way to return values: Result<Value,Error> (returns Value or Error)
Avoids nil usage
Contains a slightly verbose error
Uses extension to have pretty/intuitive interface: Model.from(localJSON: "myJsonFile")
Gives possibility to select bundle

Details

Xcode 14
Swift 5.6.1

Solution 1. JSON file -> Decodable

enum JSONParseError: Error {
    case fileNotFound
    case dataInitialisation(error: Error)
    case decoding(error: Error)
}

extension Decodable {
    static func from(localJSON filename: String,
                     bundle: Bundle = .main) -> Result<Self, JSONParseError> {
        guard let url = bundle.url(forResource: filename, withExtension: "json") else {
            return .failure(.fileNotFound)
        }
        let data: Data
        do {
            data = try Data(contentsOf: url)
        } catch let error {
            return .failure(.dataInitialisation(error: error))
        }

        do {
            return .success(try JSONDecoder().decode(self, from: data))
        } catch let error {
            return .failure(.decoding(error: error))
        }
    }
}

Solution 1 Usage

 struct Model: Decodable {
    let uuid: String
    let name: String
}

switch Model.from(localJSON: "myjsonfile") {
case .success(let value):
    print(value)
case .failure(let error):
    print(error)
}

Solution 2. JSON file -> Dictionary

extension Dictionary where Key == String, Value == Any {

    enum JSONParseError: Error {
        case fileNotFound(filename: String)
        case dataInitialisation(Error)
        case jsonSerialization(Error)
        case mappingFail(value: Any, toType: Any)
    }

    static func from(JSONfile url: URL) -> Result<Self, JSONParseError> {
        let data: Data
        do {
            data = try Data(contentsOf: url)
        } catch let error {
            return .failure(.dataInitialisation(error))
        }

        let jsonObject: Any
        do {
            jsonObject = try JSONSerialization.jsonObject(with: data, options: .mutableLeaves)
        } catch let error {
            return .failure(.jsonSerialization(error))
        }

        guard let jsonResult = jsonObject as? Self else {
            return .failure(.mappingFail(value: jsonObject, toType: Self.Type.self))
        }

        return .success(jsonResult)
    }

    static func from(localJSONfile name: String) -> Result<Self, JSONParseError> {
        let fileType = "json"
        let fullFileName = name + (name.contains(fileType) ? "" : ".\(fileType)")
        guard let path = Bundle.main.path(forResource: fullFileName, ofType: "") else {
            return .failure(.fileNotFound(filename: fullFileName))
        }
        return from(JSONfile: URL(fileURLWithPath: path))
    }
}

Solution 2 Usage

switch [String: Any].from(localJSONfile: "file.json") {
// OR switch [String: Any].from(localJSONfile: "file.json") {
// OR switch [String: Any].from(JSONfile: url) {
case let .success(dictionary):
    print(dictionary)
case let .failure(error):
    print("ERROR: \(error)")
}

Solution 1 - doesn't work for me - always gets to fileNotFound case even if checking it before: if FileManager().fileExists(atPath: path!.path) { switch Model.from(localJSON: path!.path){...

Abdulaziz Noor · Accepted Answer · 2015-03-07 16:20:16Z

7

This worked great with me

func readjson(fileName: String) -> NSData{

    let path = NSBundle.mainBundle().pathForResource(fileName, ofType: "json")
    let jsonData = NSData(contentsOfMappedFile: path!)

    return jsonData!
}

answered Mar 7, 2015 at 16:20

Abdulaziz Noor

6,4233 gold badges21 silver badges21 bronze badges

Comments

will.fiset · Accepted Answer · 2015-05-30 15:48:10Z

7

Here is my solution using SwiftyJSON

if let path : String = NSBundle.mainBundle().pathForResource("filename", ofType: "json") {
    if let data = NSData(contentsOfFile: path) {

        let json = JSON(data: data)

    }
}

answered May 30, 2015 at 15:48

will.fiset

1,5821 gold badge21 silver badges29 bronze badges

Comments

Maciej Kuliszkiewicz · Accepted Answer · 2017-02-02 22:27:20Z

7

fileprivate class BundleTargetingClass {}
func loadJSON<T>(name: String) -> T? {
  guard let filePath = Bundle(for: BundleTargetingClass.self).url(forResource: name, withExtension: "json") else {
    return nil
  }

  guard let jsonData = try? Data(contentsOf: filePath, options: .mappedIfSafe) else {
    return nil
  }

  guard let json = try? JSONSerialization.jsonObject(with: jsonData, options: .allowFragments) else {
    return nil
  }

  return json as? T
}

👆🏻 copy-paste ready, 3rd party framework independent solution.

usage 👇🏻

let json:[[String : AnyObject]] = loadJSON(name: "Stations")!

answered Feb 2, 2017 at 22:27

Maciej Kuliszkiewicz

713 silver badges3 bronze badges

1 Comment

Brian Bird Over a year ago

this worked for me. I needed to hard code a searchable list of drugs into an app. I got the json file from mySQL database. I dropped the json file into my XCODE project running above in viewDidLoad and bam I had my json dictionary !!!

Peter Kreinz · Accepted Answer · 2019-01-31 14:08:03Z

7

Swift 4: Try out my solution:

test.json

{
    "person":[
        {
            "name": "Bob",
            "age": "16",
            "employed": "No"
        },
        {
            "name": "Vinny",
            "age": "56",
            "employed": "Yes"
        }
    ]
}

RequestCodable.swift

import Foundation

struct RequestCodable:Codable {
    let person:[PersonCodable]
}

PersonCodable.swift

import Foundation

struct PersonCodable:Codable {
    let name:String
    let age:String
    let employed:String
}

Decodable+FromJSON.swift

import Foundation

extension Decodable {

    static func fromJSON<T:Decodable>(_ fileName: String, fileExtension: String="json", bundle: Bundle = .main) throws -> T {
        guard let url = bundle.url(forResource: fileName, withExtension: fileExtension) else {
            throw NSError(domain: NSURLErrorDomain, code: NSURLErrorResourceUnavailable)
        }

        let data = try Data(contentsOf: url)

        return try JSONDecoder().decode(T.self, from: data)
    }
}

Example:

let result = RequestCodable.fromJSON("test") as RequestCodable?

result?.person.compactMap({ print($0) }) 

/*
PersonCodable(name: "Bob", age: "16", employed: "No")
PersonCodable(name: "Vinny", age: "56", employed: "Yes")
*/

edited Jan 31, 2019 at 14:08

answered Jan 4, 2019 at 11:03

Peter Kreinz

8,7851 gold badge73 silver badges53 bronze badges

2 Comments

NeverwinterMoon Over a year ago

Your fromJSON extension function throws, yet in the example you call it without the try keyword. This code will not compile.

NeverwinterMoon Over a year ago

Also, for fromJSON you use an Decodable extension, yet you don't use any information from the Decodable type but provide additional (completely useless) generics.

David Buck · Accepted Answer · 2020-06-08 09:58:06Z

7

Use this generic function

func readJSONFromFile<T: Decodable>(fileName: String, type: T.Type) -> T? {
    if let url = Bundle.main.url(forResource: fileName, withExtension: "json") {
        do {
            let data = try Data(contentsOf: url)
            let decoder = JSONDecoder()
            let jsonData = try decoder.decode(T.self, from: data)
            return jsonData
        } catch {
            print("error:\(error)")
        }
    }
    return nil
}

with this line of code:

let model = readJSONFromFile(fileName: "Model", type: Model.self)

for this type:

struct Model: Codable {
    let tall: Int
}

edited Jun 8, 2020 at 9:58

David Buck

3,87740 gold badges54 silver badges73 bronze badges

answered Jun 8, 2020 at 9:25

user12410581

Comments

Abraham Simpson · Accepted Answer · 2020-02-17 20:38:05Z

6

The following code works for me. I am using Swift 5

let path = Bundle.main.path(forResource: "yourJSONfileName", ofType: "json")
var jsonData = try! String(contentsOfFile: path!).data(using: .utf8)!

Then, if your Person Struct (or Class) is Decodable (and also all of its properties), you can simply do:

let person = try! JSONDecoder().decode(Person.self, from: jsonData)

I avoided all the error handling code to make the code more legible.

edited Feb 17, 2020 at 20:38

answered Feb 17, 2020 at 20:28

Abraham Simpson

3503 silver badges9 bronze badges

Comments

Rob · Accepted Answer · 2015-05-27 05:05:25Z

I'm providing another answer because none of the ones here are geared toward loading the resource from the test bundle. If you are consuming a remote service that puts out JSON and want to unit test parsing the results without hitting the actual service, you take one or more responses and put them into files in the Tests folder in your project.

func testCanReadTestJSONFile() {
    let path = NSBundle(forClass: ForecastIOAdapterTests.self).pathForResource("ForecastIOSample", ofType: "json")
    if let jsonData = NSData(contentsOfFile:path!) {
        let json = JSON(data: jsonData)
        if let currentTemperature = json["currently"]["temperature"].double {
            println("json: \(json)")
            XCTAssertGreaterThan(currentTemperature, 0)
        }
    }
}

This also uses SwiftyJSON but the core logic of getting the test bundle and loading the file is the answer to the question.

iAj · Accepted Answer · 2017-08-02 10:01:54Z

4

Updated for Swift 3 with safest way

    private func readLocalJsonFile() {

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

        do {
            let jsonData = try Data(contentsOf: urlPath, options: .mappedIfSafe)

            if let jsonDict = try JSONSerialization.jsonObject(with: jsonData, options: .mutableContainers) as? [String: AnyObject] {

                if let personArray = jsonDict["person"] as? [[String: AnyObject]] {

                    for personDict in personArray {

                        for (key, value) in personDict {

                            print(key, value)
                        }
                        print("\n")
                    }
                }
            }
        }

        catch let jsonError {
            print(jsonError)
        }
    }
}

answered Aug 2, 2017 at 10:01

iAj

3,8271 gold badge34 silver badges34 bronze badges

1 Comment

NSGodMode Over a year ago

I prefer this answer because it shows how to actually loop through and access each value. Thanks

Khushboo · Accepted Answer · 2017-01-20 10:59:35Z

Latest swift 3.0 absolutely working

func loadJson(filename fileName: String) -> [String: AnyObject]?
{
    if let url = Bundle.main.url(forResource: fileName, withExtension: "json") 
{
      if let data = NSData(contentsOf: url) {
          do {
                    let object = try JSONSerialization.jsonObject(with: data as Data, options: .allowFragments)
                    if let dictionary = object as? [String: AnyObject] {
                        return dictionary
                    }
                } catch {
                    print("Error!! Unable to parse  \(fileName).json")
                }
            }
            print("Error!! Unable to load  \(fileName).json")
        }
        return nil
    }

Marco Leong · Accepted Answer · 2019-03-26 04:58:46Z

Swift 4 JSON to Class with Decodable - for those who prefer classes

Define the classes as follows:

class People: Decodable {
  var person: [Person]?

  init(fileName : String){
    // url, data and jsonData should not be nil
    guard let url = Bundle.main.url(forResource: fileName, withExtension: "json") else { return }
    guard let data = try? Data(contentsOf: url) else { return }
    guard let jsonData = try? JSONDecoder().decode(People.self, from: data) else { return }

    // assigns the value to [person]
    person = jsonData.person
  }
}

class Person : Decodable {
  var name: String
  var age: String
  var employed: String
}

Usage, pretty abstract:

let people = People(fileName: "people")
let personArray = people.person

This allow methods for both People and Person classes, variables (attributes) and methods can also marked as private if needed.

Binoy jose · Accepted Answer · 2021-07-21 16:50:53Z

Swift 5+

Decoding the jsonData with your Struct

if let jsonData = readFile(forName: <your file name>) {

do {
                let decodedData = try JSONDecoder().decode(<your struct name>.self, from: jsonData)
                return decodedData.<what you expect>
            } catch { print("JSON decode error") }
}

This will read the file and return jsonData

In case you are actually in another bundle (test for instance), use:
let bundlePath = Bundle(for: type(of: self)).path(forResource: name, ofType: "json")

private func readFile(forName name: String) -> Data? {
        do {

            if let bundlePath = Bundle.main.path(forResource: name, ofType: "json"),
                let jsonData = try String(contentsOfFile: bundlePath).data(using: .utf8) {
                return jsonData
            }
        } catch {
            print(error)
        }
        return nil
    }

Kudos · Accepted Answer · 2022-02-28 11:28:03Z

2

I wasted my time in locating file which was located in my project with name Jsondata.json. But I weren't able to locate my File through code....

Solution: Make sure that your Jsondata.json file is added in Project> Build Phases> Copy Bundle Resources. Otherwise you wont be able to get file and Bundle.main.url(forResource: fileName, withExtension: "json") will give you nil always.

answered Feb 28, 2022 at 11:28

Kudos

1,51813 silver badges23 bronze badges

Comments

cabaji99 · Accepted Answer · 2022-09-06 19:03:38Z

2

Swift 5 answer worked for me, except that is missing that i must add a empty file, rename it as xxx.json after it works, and using generics.

func loadJson<T:Codable>(filename fileName: String) -> T? {
        if let url = Bundle.main.url(forResource: fileName, withExtension: "json") {
            do {
                let data = try Data(contentsOf: url)
                let decoder = JSONDecoder()
                return  try decoder.decode(T.self, from: data)
            } catch {
                print("error:\(error)")
            }
        }
        return nil
    }

code

answered Sep 6, 2022 at 19:03

cabaji99

1,46513 silver badges10 bronze badges

Comments

Community · Accepted Answer · 2017-05-23 12:10:44Z

1

Based on Abhishek's answer, for iOS 8 this would be:

let masterDataUrl: NSURL = NSBundle.mainBundle().URLForResource("masterdata", withExtension: "json")!
let jsonData: NSData = NSData(contentsOfURL: masterDataUrl)!
let jsonResult: NSDictionary = NSJSONSerialization.JSONObjectWithData(jsonData, options: nil, error: nil) as! NSDictionary
var persons : NSArray = jsonResult["person"] as! NSArray

edited May 23, 2017 at 12:10

CommunityBot

11 silver badge

answered Jun 30, 2015 at 19:24

David Poxon

2,5435 gold badges25 silver badges46 bronze badges

1 Comment

David Poxon Over a year ago

Are you using Swift 2.0? Then yes, that would be the case. This was answered pre-2.0.

anoop4real · Accepted Answer · 2017-09-03 19:14:03Z

1

This worked for me with XCode 8.3.3

func fetchPersons(){

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

        do {

            let jsonData = try Data(contentsOf: pathURL, options: .mappedIfSafe)

            let jsonResult = try JSONSerialization.jsonObject(with: jsonData, options: .mutableContainers) as! [String: Any]
            if let persons = jsonResult["person"] as? [Any]{

                print(persons)
            }

        }catch(let error){
            print (error.localizedDescription)
        }
    }
}

answered Sep 3, 2017 at 19:14

anoop4real

7,7184 gold badges56 silver badges59 bronze badges

Comments

Saranjith · Accepted Answer · 2018-07-10 12:09:20Z

1

Swift 4.1 Updated Xcode 9.2

if let filePath = Bundle.main.path(forResource: "fileName", ofType: "json"), let data = NSData(contentsOfFile: filePath) {

     do {
      let json = try JSONSerialization.jsonObject(with: data as Data, options: JSONSerialization.ReadingOptions.allowFragments)        
        }
     catch {
                //Handle error
           }
 }

answered Jul 10, 2018 at 12:09

Saranjith

11.7k6 gold badges77 silver badges133 bronze badges

1 Comment

vadian Over a year ago

There is nothing new, quite the contrary: Don't use NSData in Swift 3+, and .allowFragments is pointless in this case.

oscar castellon · Accepted Answer · 2018-10-20 10:01:22Z

First create a Struc codable like this:

  struct JuzgadosList : Codable {
    var CP : Int
    var TEL : String
    var LOCAL : String
    var ORGANO : String
    var DIR : String
}

Now declare the variable

 var jzdosList = [JuzgadosList]()

Read from main directory

func getJsonFromDirectory() {

        if let path = Bundle.main.path(forResource: "juzgados", ofType: "json") {
            do {
                let data = try Data(contentsOf: URL(fileURLWithPath: path), options: .alwaysMapped)
                let jList = try JSONDecoder().decode([JuzgadosList].self, from: data)
                self.jzdosList = jList

                DispatchQueue.main.async() { () -> Void in
                    self.tableView.reloadData()
                }

            } catch let error {
                print("parse error: \(error.localizedDescription)")
            }
        } else {
            print("Invalid filename/path.")
        }
    }

Read from web

func getJsonFromUrl(){

        self.jzdosList.removeAll(keepingCapacity: false)

        print("Internet Connection Available!")

        guard let url = URL(string: "yourURL")  else { return }

        let request = URLRequest(url: url, cachePolicy: URLRequest.CachePolicy.reloadIgnoringLocalCacheData, timeoutInterval: 60.0)
        URLSession.shared.dataTask(with: request) { (data, response, err) in
            guard let data = data else { return }
            do {
                let jList = try JSONDecoder().decode([JuzgadosList].self, from: data)
                self.jzdosList = jList

                DispatchQueue.main.async() { () -> Void in
                    self.tableView.reloadData()
                }
            } catch let jsonErr {
                print("Error serializing json:", jsonErr)
            }
        }.resume()
    }

ASHISH R · Accepted Answer · 2019-11-21 18:55:26Z

1

//change type based on your struct and right JSON file

let quoteData: [DataType] =
    load("file.json")

func load<T: Decodable>(_ filename: String, as type: T.Type = T.self) -> T {
    let data: Data

    guard let file = Bundle.main.url(forResource: filename, withExtension: nil)
        else {
            fatalError("Couldn't find \(filename) in main bundle.")
    }

    do {
        data = try Data(contentsOf: file)
    } catch {
        fatalError("Couldn't load \(filename) from main bundle:\n\(error)")
    }

    do {
        let decoder = JSONDecoder()
        return try decoder.decode(T.self, from: data)
    } catch {
        fatalError("Couldn't parse \(filename) as \(T.self):\n\(error)")
    }
}

answered Nov 21, 2019 at 18:55

ASHISH R

4,1891 gold badge24 silver badges16 bronze badges

Comments

Tal Sahar · Accepted Answer · 2022-10-11 17:50:21Z

For those who is looking for reusable function I made a class that responsible for JSON loading.

import Foundation

class JSONLoader {
    static func load<T: Decodable>(resource: String, type: T.Type) -> T {
        guard let file = Bundle.main.url(forResource: resource, withExtension: nil) else {
            fatalError("Couldn't find \(resource) in main bundle.")
        }
        let data: Data
        do {
            data = try Data(contentsOf: file)
        } catch {
            fatalError("Couldn't load \(resource) from main bundle:\n\(error)")
        }
        do {
            return try JSONDecoder().decode(type, from: data)
        } catch {
            fatalError("Couldn't parse \(resource) as \(T.self):\n\(error)")
        }
    }
    
    static func load<T: Decodable>(resource: String) -> T {
        load(resource: resource, type: T.self)
    }
}
// Usage:
let employee1 = JSONLoader.load("employee.json", Employee.self)
let employee2: Employee = JSONLoader.load("employee.json")

s3cretshadow · Accepted Answer · 2022-10-20 10:51:55Z

A generic approach can be like that:

Create json file with Response class name string

struct Response: Codable,FileDecodable {
    typealias T = Self
    let names:[Data]
}
protocol FileDecodable{
   associatedtype T:Codable
   static func loadJson() ->T?
}

extension FileDecodable{
    static func loadJson() -> T? {
        let fileName = String(describing: T.self)
        if let url = Bundle.main.url(forResource: fileName, withExtension: "json")     {
            do {
                let data = try Data(contentsOf: url)
                let decoder = JSONDecoder()
                let jsonData = try decoder.decode(T.self, from: data)
                return jsonData
            } catch {
                print("error:\(error)")
            }
        }
        return nil
    }
}

Collectives™ on Stack Overflow

35 Answers 35

Swift 4.0:

12 Comments

1 Comment

5 Comments

Swift 5.1, Xcode 11

Comments

Comments

Comments

Comments

Comments

Comments

One more answer here???

What is the different

Details

Solution 1. JSON file -> Decodable

Solution 1 Usage

Solution 2. JSON file -> Dictionary

Solution 2 Usage

1 Comment

Comments

Comments

1 Comment

2 Comments

Comments

Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Comments

1 Comment

Comments

Swift 4.1 Updated Xcode 9.2

1 Comment

Comments

Comments

Comments

Comments

Linked

Related