Odczytywanie pliku JSON za pomocą Swift

205

Naprawdę mam problem z odczytaniem pliku JSON w Swift, aby móc się nim bawić. Spędziłem najlepszą część 2 dni na ponownym wyszukiwaniu i wypróbowywaniu różnych metod, ale na razie nie mam szczęścia, więc zapisałem się do StackOverFlow, aby sprawdzić, czy ktoś może skierować mnie w dobrym kierunku .....

Mój plik JSON nazywa się test.json i zawiera następujące elementy:

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

Plik jest zapisywany bezpośrednio w dokumentach i uzyskuję do niego dostęp za pomocą następującego kodu:

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

Jeśli ktokolwiek może po prostu popchnąć mnie we właściwym kierunku, jak mogę dokonać serializacji pliku JSON i umieścić go w dostępnym obiekcie Swift, będę wiecznie wdzięczny!

Z poważaniem,

Krivvenz.

Krivvenz
źródło
1
użyj parametru błędu ...
Matthias Bauch
2
Proszę zamieścić aktualny, kompilowalny kod. Tak jak jest teraz, pathjest widoczny tylko w ifzakresie i nierozwiązany, gdy go używasz NSData(contentsOfFile, options, error); masz także literówki w nazwach enum.
Kreiri,
1
Moje API jest w pełni zaktualizowane do Swift 3: github.com/borchero/WebParsing
borchero 29.09.16
to jest klucz -> „wartości”: „% WARTOŚĆ OBCIĄŻENIA z pliku tmclass.json%” i muszę przeanalizować inny plik JSON z pliku, a następnie jak to osiągnąć w SWIFT?
Mayur Shinde,

Odpowiedzi:

287

Postępuj zgodnie z poniższym kodem:

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

Tablica „osoby” będzie zawierać wszystkie dane dla kluczowej osoby. Iteruj przez, aby go pobrać.

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
źródło
4
Byłoby bardziej pomocne, gdybyś wyjaśnił, dlaczego / jak to rozwiązuje problem opisany w pytaniu, zamiast po prostu prezentować sporo kodu.
Martin R
Cześć Abhishek - Dziękuję za odpowiedź, ale nadal nie działa. Powoduje to awarię aplikacji z poniższym błędem: 2014-06-25 16: 02: 04.146 Przechwytywanie H & S [4937: 131932] *** Zakończenie aplikacji z powodu nieprzechwyconego wyjątku „NSInvalidArgumentException”, powód: „*** - [_NSPlaceholderData initWithContentsOfFile: opcje: błąd:]: argument pliku zerowego „*** Stos pierwszego wywołania rzutu: jakieś pomysły, dlaczego tak jest? Dla opcji jsonData: I put (ścieżka, opcje: NSDataReadingOptions.DataReadingMappedIfSafe, błąd: zero)
Krivvenz
Twoja ścieżka do pliku jest nieprawidłowa. W rzeczywistości nie ma pliku o nazwie test.json w określonej przez ciebie ścieżce. Sprawdź poprawność lokalizacji pliku
Abhishek
15
„let jsonData = NSData (contentOfFile: ścieżka!)” zamiast „let jsonData = NSData.dataWithContentsOfFile (ścieżka, opcje: .DataReadingMappedIfSafe, błąd: zero)”
tong
7
Lepiej jednak użyć tutaj instrukcji guard else zamiast piramidy zagłady.
Zonily Jame,
140

Jeśli ktoś szuka SwiftyJSON Odpowiedź:
Aktualizacja:
Dla 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.")
}
Aks
źródło
2
to zmieniło mnie w swiftyJSON i kartage! dzięki :)
Paul Wand
użyłem go tylko do odkrycia, że ​​brakuje mu mapowania obiektów, następnym razem spróbuję innej biblioteki
Elazaron
Aby uniknąć błędu wklejania kopii w swift 3: NSData i NSError zmieniły się w Data and Error.
selva
Wypróbowałem kilka różnych metod i to zadziałało najlepiej w Swift 3
crobicha
(!), Ponieważ MacOS 10.6 / iOS 4 jest API url(forResourcew (NS)Bundlecelu uniknięcia dodatkowego kroku, aby utworzyć URL
Vadian
102

Swift 4 przy użyciu dekodowania

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
}

Szybki 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
źródło
9
Powinno to zostać przeniesione do nowej funkcji dokumentacji lub oznaczone jako poprawna odpowiedź.
system
24

Xcode 8 Swift 3 odczytał json z aktualizacji pliku:

    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
źródło
14

Zaktualizowano nazwy dla Swift 3.0

Na podstawie odpowiedzi na Abhishek i odpowiedzi Druva za

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
źródło
12

Uproszczenie przykładu dostarczonego przez Petera Kreinza. Działa z Swift 4.2.

Funkcja rozszerzenia:

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

Przykładowy model:

struct Service: Decodable {
  let name: String
}

Przykładowe użycie:

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

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

// use output if all good

Przykład będzie również działał z tablicami:

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

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

// use output if all good

Zauważ, że nie zapewniamy żadnych niepotrzebnych składników ogólnych, dlatego nie musimy rzutować wyniku analizy.

NeverwinterMoon
źródło
10

Odpowiedź Swift 2.1 (na podstawie Abhisheka):

    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
źródło
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)")
        }
    }

Wynik:

Name: Bob,  age: 16, employed: No
Name: Vinny,  age: 56, employed: Yes
Ashok R.
źródło
7

Działa to świetnie ze mną

func readjson(fileName: String) -> NSData{

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

    return jsonData!
}
Abdulaziz Noor
źródło
7

Oto moje rozwiązanie wykorzystujące SwiftyJSON

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

        let json = JSON(data: data)

    }
}
will.fiset
źródło
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
}

Ready gotowe do kopiowania i wklejania, niezależne od frameworka rozwiązanie niezależne.

użycie 👇🏻

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

Maciej Banasiewicz
źródło
to działało dla mnie. Musiałem zakodować na stałe listę leków, które można przeszukiwać, do aplikacji. Mam plik json z bazy danych mySQL. Upuściłem plik json do mojego projektu XCODE działającego powyżej w viewDidLoad i bam miałem mój słownik json !!!
Brian
5

Podaję inną odpowiedź, ponieważ żaden z nich nie ma na celu załadowania zasobu z pakietu testowego. Jeśli korzystasz ze zdalnej usługi, która wysyła JSON i chcesz przeprowadzić test jednostkowy parsowania wyników bez trafienia w rzeczywistą usługę, bierzesz jedną lub więcej odpowiedzi i umieszczasz je w plikach w folderze Testy w swoim projekcie.

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

To również używa SwiftyJSON, ale podstawowa logika pobierania pakietu testowego i ładowania pliku jest odpowiedzią na pytanie.

Obrabować
źródło
5

Swift 4: Wypróbuj moje rozwiązanie:

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
}

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

Przykład:

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
źródło
1
Twoja fromJSONfunkcja rozszerzenia rzuca, ale w przykładzie wywołujesz ją bez trysłowa kluczowego. Ten kod nie będzie się kompilował.
NeverwinterMoon
Ponadto, fromJSONjeśli używasz rozszerzenia Decodable, nie używasz żadnych informacji z typu Decodable, ale zapewniasz dodatkowe (całkowicie bezużyteczne) generyczne.
NeverwinterMoon
3

Najnowszy swift 3.0 absolutnie działa

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
źródło
3

Przesuń 4 JSONna ClasszDecodable - dla tych, którzy wolą zajęcia

Zdefiniuj klasy w następujący sposób:

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
}

Zastosowanie, dość abstrakcyjne:

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

Pozwala to na metody zarówno dla klas, jak Peoplei Personzmiennych, atrybutów i metod, które mogą być również oznaczone w privaterazie potrzeby.

Marco Leong
źródło
3

Poniższy kod działa dla mnie. Używam Swift 5

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

Następnie, jeśli Twoja Struktura Osoby (lub Klasa) jest Dekodowalna (a także wszystkie jej właściwości), możesz po prostu zrobić:

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

Unikałem całego kodu obsługi błędów, aby kod był bardziej czytelny.

Abraham Simpson
źródło
2

Zaktualizowano dla Swift 3 w najbezpieczniejszy sposób

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

wprowadź opis zdjęcia tutaj

iAj
źródło
2

Swift 5.1, Xcode 11

Możesz użyć tego:


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
źródło
1

W oparciu o odpowiedź Abhisheka dla iOS 8 byłoby to:

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
źródło
Czy używasz Swift 2.0? Tak, tak by było. Odpowiedzi udzielono przed wersją 2.0.
David Poxon
1

Działa to dla mnie z 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
źródło
1

Swift 4.1 Zaktualizowano 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
źródło
3
Nie ma nic nowego, wręcz przeciwnie: nie używaj NSDataw Swift 3+, .allowFragmentsw tym przypadku nie ma sensu.
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
źródło
0

Użyłem poniższego kodu, aby pobrać JSON z pliku FAQ-data.json znajdującego się w katalogu projektu.

Wdrażam w Xcode 7.3 za pomocą 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()
    }

Struktura pliku JSON:

{
    "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
źródło
0

Mogę również polecić samouczek JSON Swift Ray Wenderlicha (który obejmuje również niesamowitą alternatywę SwiftyJSON, Połysk ). Fragment (który sam w sobie nie odpowiada w pełni na plakat, ale wartością dodaną tej odpowiedzi jest link, więc proszę nie -1 za to):

W Objective-C parsowanie i deserializacja JSON jest dość prosta:

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

W Swift parsowanie i deserializowanie JSON jest nieco bardziej nużące ze względu na opcje Swift i bezpieczeństwo typu [ale jako część Swift 2.0, guardinstrukcja została wprowadzona, aby pomóc pozbyć się zagnieżdżonych ifinstrukcji:

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

Oczywiście w XCode 8.x wystarczy dwukrotnie stuknąć spację i powiedzieć „Hej, Siri, proszę deserializować JSON dla mnie w Swift 3.0 z wcięciami / tabulatorami”.

AmitaiB
źródło
0

SWIFTYJSON WERSJA 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
źródło
0

Najpierw utwórz kod Struc, taki jak ten:

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

Teraz zadeklaruj zmienną

 var jzdosList = [JuzgadosList]()

Czytaj z głównego katalogu

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

Czytaj z sieci

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
źródło
0

Użyj tej funkcji ogólnej

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
}

z tym wierszem kodu:

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

dla tego typu:

struct Model: Codable {
    let tall: Int
}
Khaled Annajar
źródło