Einlesen einer JSON-Datei mit Swift

205

Ich habe wirklich Probleme damit, eine JSON-Datei in Swift einzulesen, damit ich damit herumspielen kann. Ich habe den größten Teil von 2 Tagen damit verbracht, verschiedene Methoden erneut zu suchen und auszuprobieren, aber noch kein Glück. Deshalb habe ich mich bei StackOverFlow angemeldet, um zu sehen, ob mich jemand in die richtige Richtung weisen kann.

Meine JSON-Datei heißt test.json und enthält Folgendes:

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

Die Datei wird direkt in den Dokumenten gespeichert und ich greife mit folgendem Code darauf zu:

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..... 

Wenn mir jemand nur einen Schub in die richtige Richtung geben kann, wie ich die JSON-Datei de-serialisieren und in ein zugängliches Swift-Objekt einfügen kann, bin ich auf ewig dankbar!

Mit freundlichen Grüßen,

Krivvenz.

Krivvenz
quelle
1
Verwenden Sie den
Matthias Bauch
2
Bitte posten Sie den aktuellen, kompilierbaren Code. So wie es jetzt ist, pathist es nur im ifBereich sichtbar und ungelöst, wenn Sie es in verwenden NSData(contentsOfFile, options, error). Sie haben auch Tippfehler in Aufzählungsnamen.
Kreiri
1
Meine API ist für Swift 3 vollständig aktualisiert: github.com/borchero/WebParsing
borchero
Dies ist der Schlüssel -> "Werte": "% LOAD VALUE FROM tmclass.json Datei%" und ich muss einen anderen JSON aus der Datei analysieren. Wie kann ich dies dann in SWIFT erreichen?
Mayur Shinde

Antworten:

287

Folgen Sie dem folgenden 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
            }
        }
     }
}

Das Array "Personen" enthält alle Daten für die Schlüsselperson. Iterieren Sie durch, um es zu holen.

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
      }
}
Abhishek
quelle
4
Es wäre hilfreicher, wenn Sie erklären würden, warum / wie dies das in der Frage beschriebene Problem löst, anstatt nur eine Menge Code zu präsentieren.
Martin R
Hallo Abhishek - Danke für deine Antwort, aber es funktioniert immer noch nicht. Dies führt dazu, dass die Anwendung mit dem folgenden Fehler abstürzt: 2014-06-25 16: 02: 04.146 H & S Capture [4937: 131932] *** Beenden der App aufgrund der nicht erfassten Ausnahme 'NSInvalidArgumentException', Grund: '*** - [_NSPlaceholderData initWithContentsOfFile: options: error:]: nil file argument '*** Erster Aufrufstapel: Irgendwelche Ideen, warum dies so ist? Für die jsonData-Optionen: Ich setze (Pfad, Optionen: NSDataReadingOptions.DataReadingMappedIfSafe, Fehler: Null)
Krivvenz
Ihr Dateipfad ist nicht korrekt. Tatsächlich befindet sich unter dem von Ihnen angegebenen Pfad keine Datei mit dem Namen test.json. Bitte überprüfen Sie den korrekten Speicherort der Datei
Abhishek
15
"let jsonData = NSData (contentOfFile: path!)" anstelle von "let jsonData = NSData.dataWithContentsOfFile (Pfad, Optionen: .DataReadingMappedIfSafe, Fehler: null)"
tong
7
Es ist jedoch besser, hier Guard-else-Aussagen zu verwenden, als diese Pyramide des Untergangs.
Zonily Jame
139

Wenn jemand nach SwiftyJSON sucht Antwort:
Update:
FürSwift 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.")
}
Aks
quelle
2
das hat mich auf swiftyJSON und karthago gebracht! danke :)
Paul Wand
Ich habe es nur benutzt, um
herauszufinden
So vermeiden Sie Fehler beim Kopieren und Einfügen in Swift 3: NSData und NSError wurden zu Data and Error.
Selva
Ich habe ein paar verschiedene Methoden ausprobiert und dies funktionierte am besten für mich in Swift 3
crobicha
(!) Seit MacOS 10.6 / iOS 4 gibt es eine API url(forResourcein (NS)Bundledem zusätzlichen Schritt zu vermeiden , dass die URL zu erstellen
Vadian
102

Swift 4 mit 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
}
yarlg
quelle
9
Dies sollte in die neue Dokumentationsfunktion verschoben oder als die richtige Antwort markiert werden.
System
24

Xcode 8 Swift 3 liest json aus dem Datei-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 {}
    }
ben
quelle
14

Aktualisierte Namen für Swift 3.0

Basierend auf Abhisheks Antwort und Druvas Antwort

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
}
Nick Graham
quelle
12

Vereinfachung des Beispiels von Peter Kreinz. Funktioniert mit Swift 4.2.

Die Erweiterungsfunktion:

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
  }
}

Das Beispielmodell:

struct Service: Decodable {
  let name: String
}

Die Beispielverwendung:

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

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

// use output if all good

Das Beispiel funktioniert auch mit Arrays:

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

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

// use output if all good

Beachten Sie, dass wir keine unnötigen Generika bereitstellen, sodass wir das Ergebnis der Analyse nicht umsetzen müssen.

NeverwinterMoon
quelle
10

Schnelle 2.1-Antwort (basierend auf Abhisheks):

    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 {}
    }
kjm
quelle
10

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)")
        }
    }

Ausgabe:

Name: Bob,  age: 16, employed: No
Name: Vinny,  age: 56, employed: Yes
Ashok R.
quelle
7

Das hat bei mir super geklappt

func readjson(fileName: String) -> NSData{

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

    return jsonData!
}
Abdulaziz Noor
quelle
7

Hier ist meine Lösung mit SwiftyJSON

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

        let json = JSON(data: data)

    }
}
will.fiset
quelle
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-fähige, Framework-unabhängige Lösung von Drittanbietern.

Verwendung 👇🏻

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

Maciej Banasiewicz
quelle
das hat bei mir funktioniert. Ich musste eine durchsuchbare Liste von Drogen in eine App codieren. Ich habe die JSON-Datei aus der mySQL-Datenbank erhalten. Ich habe die JSON-Datei in meinem XCODE-Projekt abgelegt, das oben in viewDidLoad ausgeführt wurde, und ich hatte mein JSON-Wörterbuch !!!
Brian
5

Ich gebe eine andere Antwort, da keiner der hier darauf ausgerichtet ist, die Ressource aus dem Testpaket zu laden. Wenn Sie einen Remotedienst verwenden, der JSON ausgibt, und die Ergebnisse in einem Unit-Test analysieren möchten, ohne den eigentlichen Dienst zu treffen, nehmen Sie eine oder mehrere Antworten und legen sie in Dateien im Ordner "Tests" Ihres Projekts ab.

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)
        }
    }
}

Dies verwendet auch SwiftyJSON, aber die Kernlogik zum Abrufen des Testpakets und zum Laden der Datei ist die Antwort auf die Frage.

rauben
quelle
5

Swift 4: Probieren Sie meine Lösung aus:

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
}

Decodierbar + 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)
    }
}

Beispiel:

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")
*/
Peter Kreinz
quelle
1
Ihre fromJSONErweiterungsfunktion wird ausgelöst, im Beispiel wird sie jedoch ohne das trySchlüsselwort aufgerufen . Dieser Code wird nicht kompiliert.
NeverwinterMoon
Auch für fromJSONSie eine Dekodierbare Erweiterung verwenden, aber verwenden Sie keine Informationen aus dem Dekodierbare Typ , aber zusätzliche (völlig nutzlos) Generika.
NeverwinterMoon
3

Neueste Swift 3.0 funktioniert absolut

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
    }
Khushboo
quelle
3

Swift 4 JSONto Classwith Decodable- für diejenigen, die Klassen bevorzugen

Definieren Sie die Klassen wie folgt:

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
}

Verwendung, ziemlich abstrakt:

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

Dies ermöglicht Methoden für beide Peopleund PersonKlassen, Variablen (Attribute) und Methoden können privatebei Bedarf auch markiert werden.

Marco Leong
quelle
2

Aktualisiert für Swift 3 auf sicherste Weise

    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)
        }
    }
}

Geben Sie hier die Bildbeschreibung ein

iAj
quelle
2

Der folgende Code funktioniert für mich. Ich benutze Swift 5

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

Wenn Ihre Personenstruktur (oder Klasse) dekodierbar ist (und auch alle ihre Eigenschaften), können Sie einfach Folgendes tun:

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

Ich habe den gesamten Fehlerbehandlungscode vermieden, um den Code besser lesbar zu machen.

Abraham Simpson
quelle
1

Basierend auf Abhisheks Antwort wäre dies für iOS 8:

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
David Poxon
quelle
Verwenden Sie Swift 2.0? Dann wäre das ja der Fall. Dies wurde vor 2.0 beantwortet.
David Poxon
1

Dies funktionierte bei mir mit 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)
        }
    }
}
anoop4real
quelle
1

Swift 4.1 Aktualisierter 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
           }
 }
Saranjith
quelle
3
Es gibt nichts Neues, ganz im Gegenteil: Nicht NSDatain Swift 3+ verwenden und .allowFragmentsist in diesem Fall sinnlos.
Vadian
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)")
    }
}

ASHISH RANJAN
quelle
1

Swift 5.1, Xcode 11

Sie können dies verwenden:


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(Class.self, from: data)
   else {
        return nil
   }

   return person
}
Gonzer
quelle
0

Ich habe den folgenden Code verwendet, um JSON aus der im Projektverzeichnis vorhandenen Datei FAQ-data.json abzurufen.

Ich implementiere in Xcode 7.3 mit Swift.

     func fetchJSONContent() {
            if let path = NSBundle.mainBundle().pathForResource("FAQ-data", ofType: "json") {

                if let jsonData = NSData(contentsOfFile: path) {
                    do {
                        if let jsonResult: NSDictionary = try NSJSONSerialization.JSONObjectWithData(jsonData, options: NSJSONReadingOptions.MutableContainers) as? NSDictionary {

                            if let responseParameter : NSDictionary = jsonResult["responseParameter"] as? NSDictionary {

                                if let response : NSArray = responseParameter["FAQ"] as? NSArray {
                                    responseFAQ = response
                                    print("response FAQ : \(response)")
                                }
                            }
                        }
                    }
                    catch { print("Error while parsing: \(error)") }
                }
            }
        }

override func viewWillAppear(animated: Bool) {
        fetchFAQContent()
    }

Struktur der JSON-Datei:

{
    "status": "00",
    "msg": "FAQ List ",
    "responseParameter": {
        "FAQ": [
            {                
                "question":Question No.1 here”,
                "answer":Answer goes here”,  
                "id": 1
            },
            {                
                "question":Question No.2 here”,
                "answer":Answer goes here”,
                "id": 2
            }
            . . .
        ]
    }
}
Jayprakash Dubey
quelle
0

Ich könnte auch Ray Wenderlichs Swift JSON Tutorial empfehlen (das auch die großartige SwiftyJSON-Alternative Gloss behandelt ). Ein Auszug (der von sich aus das Poster nicht vollständig beantwortet, aber der Mehrwert dieser Antwort ist der Link, also bitte keine -1 dafür):

In Objective-C ist das Parsen und Deserialisieren von JSON ziemlich einfach:

NSArray *json = [NSJSONSerialization JSONObjectWithData:JSONData
options:kNilOptions error:nil];
NSString *age = json[0][@"person"][@"age"];
NSLog(@"Dani's age is %@", age);

In Swift ist das Parsen und Deserialisieren von JSON aufgrund von Swift-Optionen und Typensicherheit etwas mühsamer. Als Teil von Swift 2.0 wurde die guardAnweisung eingeführt, um verschachtelte ifAnweisungen zu entfernen :

var json: Array!
do {
  json = try NSJSONSerialization.JSONObjectWithData(JSONData, options: NSJSONReadingOptions()) as? Array
} catch {
  print(error)
}

guard let item = json[0] as? [String: AnyObject],
  let person = item["person"] as? [String: AnyObject],
  let age = person["age"] as? Int else {
    return;
}
print("Dani's age is \(age)")

Natürlich tippen Sie in XCode 8.x einfach zweimal auf die Leertaste und sagen "Hey, Siri, bitte deserialisieren Sie diesen JSON für mich in Swift 3.0 mit Leerzeichen / Tabulatoren."

AmitaiB
quelle
0

SWIFTYJSON VERSION SWIFT 3

func loadJson(fileName: String) -> JSON {

    var dataPath:JSON!

    if let path : String = Bundle.main.path(forResource: fileName, ofType: "json") {
        if let data = NSData(contentsOfFile: path) {
             dataPath = JSON(data: data as Data)
        }
    }
    return dataPath
}
Ahmed Safadi
quelle
0

Erstellen Sie zuerst eine Struc-Codierbarkeit wie folgt:

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

Deklarieren Sie nun die Variable

 var jzdosList = [JuzgadosList]()

Aus dem Hauptverzeichnis lesen

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.")
        }
    }

Lesen Sie aus dem Internet

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()
    }
Oscar Castellon
quelle
0

Verwenden Sie diese generische Funktion

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
}

mit dieser Codezeile:

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

für diesen Typ:

struct Model: Codable {
    let tall: Int
}
Khaled Annajar
quelle