Swift Kullanarak JSON Dosyasında Okuma


206

Swift ile bir JSON dosyasını okumaya çalışıyorum, böylece onunla oynayabilirim. Ben 2 gün en iyi parçası yeniden arama ve farklı yöntemler çalışırken ama henüz hiç şans denedim bu yüzden herkes bana doğru yönde işaret edebilir görmek için StackOverFlow için kaydoldum .....

JSON dosyama test.json adı verilir ve aşağıdakileri içerir:

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

Dosya doğrudan belgelerde saklanır ve aşağıdaki kodu kullanarak dosyaya erişirim:

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

Herkes bana JSON dosyasının serisini nasıl serileştirebilir ve erişilebilir bir Swift nesnesine nasıl koyabileceğim konusunda doğru yönde bir itme yapabilirse sonsuza dek minettar olacağım!

Saygılarımla,

Krivvenz.


1
hata parametresini kullanın ...
Matthias Bauch

2
Lütfen gerçek, derlenebilir kod gönderin. Şimdi olduğu gibi, pathsadece ifkapsamda görülebilir ve kullandığınızda çözülmez NSData(contentsOfFile, options, error); numaralandırma adlarında da yazım hataları var.
Kreiri


Bu anahtar -> "değerler": "tmclass.json% dosyasından% LOAD VALUE" ve ben dosyadan başka bir JSON ayrıştırmak gerekiyor sonra nasıl SWIFT bu elde edebilirsiniz?
Mayur Shinde

Yanıtlar:


288

Aşağıdaki kodu izleyin:

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

"Kişiler" dizisi, kilit kişi için tüm verileri içerecektir. Almak için yineleme yoluyla yineleyin.

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

4
Bunun, yalnızca bir grup kod sunmak yerine, soruda açıklanan sorunu neden / nasıl çözdüğünü açıklarsanız daha yararlı olacaktır.
Martin R

Merhaba Abhishek - Cevabınız için teşekkürler ama hala çalışmıyor. Bu, uygulamanın aşağıdaki hatayla kilitlenmesine neden olur: 2014-06-25 16: 02: 04.146 H & S Capture [4937: 131932] *** Yakalanmayan istisna 'NSInvalidArgumentException' nedeniyle uygulamayı sonlandırma, nedeni: '*** - [_NSPlaceholderData initWithContentsOfFile: options: hata:]: nil dosya argümanı '*** İlk çağrı çağrısı yığını: Bunun neden olduğuna dair herhangi bir fikir var mı? JsonData seçenekleri için: Ben koymak (yol, seçenekler: NSDataReadingOptions.DataReadingMappedIfSafe, hata: nil)
Krivvenz

Dosya yolunuz doğru değil. Aslında, belirttiğiniz yolda test.json adında bir dosya yoktur. Lütfen dosyanın doğru konumunu kontrol edin
Abhishek

15
yerine "let jsonData = NSData (contentOfFile: path!)" yerine "let jsonData = NSData.dataWithContentsOfFile (yol, seçenekler: .DataReadingMappedIfSafe, hata: nil)"
maşa

7
Yine de bu kıyamet piramidi yerine başka ifadeler kullanmak daha iyidir.
Zonily Jame

141

Birisi SwiftyJSON'u arıyorsa Cevap:
Güncelleme:
İçin 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.")
}

2
Bu beni swiftyJSON ve carthage oldu! teşekkürler :)
Paul Wand

Ben sadece nesne haritalama eksik keşfetmek için kullanılır, bir dahaki sefere farklı bir kütüphane çalışacağız
Elazaron

Hızlı 3'te kopyalama yapıştırma hatasını önlemek için: NSData ve NSError Veri ve Hata oldu.
selva

Birkaç farklı yöntem denedim ve bu benim için en iyisi Swift 3'te çalıştı
crobicha

(!) MacOS 10.6 yana / iOS 4 bir API var url(forResourceiçinde (NS)BundleURL oluşturmak fazladan bir adım önlemek için
Vadian

104

Decodable kullanarak Swift 4

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
}

Hızlı 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
}

10
Bu, yeni dokümantasyon özelliğine taşınmalı veya doğru yanıt olarak işaretlenmelidir.
sistem

24

Xcode 8 Swift 3 dosya güncellemesinden json okuma:

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

14

Swift 3.0 için güncellenmiş adlar

Dayanarak Abhishek cevabı ve Druva cevabı

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
}

12

Peter Kreinz tarafından sağlanan örneği basitleştirmek. Swift 4.2 ile çalışır.

Uzatma fonksiyonu:

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

Örnek model:

struct Service: Decodable {
  let name: String
}

Örnek kullanım:

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

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

// use output if all good

Örnek dizilerle de çalışacaktır:

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

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

// use output if all good

Gereksiz jenerikleri nasıl sağlamadığımıza dikkat edin, bu nedenle ayrıştırma sonucunu kullanmamız gerekmez.


10

Swift 2.1 cevabı (Abhishek'e göre):

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

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

Çıktı:

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

7

Bu benimle harika çalıştı

func readjson(fileName: String) -> NSData{

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

    return jsonData!
}

7

İşte SwiftyJSON kullanarak benim çözüm

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

        let json = JSON(data: data)

    }
}

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🏻 kopyala yapıştır hazır, 3. taraf çerçeve bağımsız çözüm.

kullanım 👇🏻

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


bu benim için çalıştı. Bir uygulamaya uyuşturucu aranabilir bir listesini zor kodlamak gerekiyordu. MySQL veritabanından json dosyasını aldım. Json dosyasını viewDidLoad ve yukarıda çalışan xCODE projeme bıraktım ve json sözlüğüm vardı !!!
Brian

5

Başka bir cevap sağlıyorum çünkü buradakilerin hiçbiri kaynağı test paketinden yüklemeye yönelik değil. JSON'u kapatan ve gerçek hizmete çarpmadan sonuçları ayrıştırma birim birim testi yapmak istiyorsanız, bir veya daha fazla yanıt alıp projenizdeki Testler klasöründeki dosyalara koyabilirsiniz.

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

Bu aynı zamanda SwiftyJSON kullanır ancak test paketini alıp dosyayı yüklemenin temel mantığı sorunun cevabıdır.


5

Swift 4: Çözümümü dene:

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
}

Çözülebilir + 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)
    }
}

Misal:

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

1
Kişisel fromJSONuzatma fonksiyonu atar, yine örnekte olmadan diyoruz tryanahtar kelime. Bu kod derlenmeyecek.
NeverwinterMoon

Ayrıca, fromJSONbir Decodable eklentisini kullandığınız için, ancak Decodable türünden herhangi bir bilgi kullanmazsınız, ancak ek (tamamen yararsız) jenerikler sağlarsınız.
NeverwinterMoon

3

En son Swift 3.0 kesinlikle çalışıyor

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
    }

3

Swift 4 JSONiçin ClassbirlikteDecodable - sınıfları tercih edenler için

Sınıfları aşağıdaki gibi tanımlayın:

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
}

Kullanımı, oldukça soyut:

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

Bu, her iki için yöntemleri sağlar Peopleve Personsınıfları, değişkenler (özellikler) ve yöntem, aynı zamanda olarak işaretlenmiş olabilir privategerekirse.


3

Aşağıdaki kod benim için çalışıyor. Swift 5 kullanıyorum

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

Ardından, Kişi Yapınız (veya Sınıfınız) Decodable (ve ayrıca tüm özellikleri) ise, şunları yapabilirsiniz:

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

Kodu daha okunaklı hale getirmek için tüm hata işleme kodlarından kaçındım.


3

Swift 5.1, Xcode 11

Bunu kullanabilirsiniz:


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
}

2

Swift 3 için en güvenli şekilde güncellendi

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

resim açıklamasını buraya girin


1

Abhishek'in cevabına dayanarak, iOS 8 için bu şöyle olurdu:

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

Swift 2.0 mı kullanıyorsunuz? Sonra evet, durum böyle olurdu. Bu, 2.0 öncesi yanıtlandı.
David Poxon

1

Bu benim için XCode 8.3.3 ile çalıştı

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

1

Swift 4.1 Güncellenmiş 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
           }
 }

3
Yeni bir şey yok, tam tersine: NSDataSwift 3+' de kullanmayın ve .allowFragmentsbu durumda anlamsızdır.
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)")
    }
}


0

Aşağıdaki kodu proje dizininde bulunan FAQ-data.json dosyasından JSON almak için kullandım .

Swift kullanarak Xcode 7.3'te uyguluyorum.

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

JSON dosyasının yapısı:

{
    "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
            }
            . . .
        ]
    }
}

0

Ayrıca Ray Wenderlich en önerebilir Swift JSON Eğitimi (aynı zamanda müthiş SwiftyJSON alternatifi kapsar Parlaklık ). Bir alıntı (kendi başına, postere tam olarak cevap vermez, ancak bu cevabın katma değeri bağlantıdır, bu yüzden bunun için -1 yok, lütfen):

Objective-C'de, JSON'un ayrıştırılması ve serileştirilmesi oldukça basittir:

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

Swift'te, JSON'un ayrıştırılması ve serileştirilmesi, Swift seçenekleri ve tip güvenliği nedeniyle biraz daha sıkıcıdır, ancak Swift 2.0'ın bir parçası olarak guardifade, iç içe ififadelerden kurtulmaya yardımcı olmak için tanıtıldı :

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

Tabii ki, XCode 8.x'te, boşluk çubuğuna iki kez hafifçe vurun ve "Hey, Siri, lütfen bu JSON'u benim için Swift 3.0'da boşluk / sekme girintileri ile serisini kaldırın."


0

SWIFTYJSON SÜRÜM 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
}

0

Önce böyle bir kodlama yapı oluşturun:

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

Şimdi değişkeni bildirin

 var jzdosList = [JuzgadosList]()

Ana dizinden okuyun

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

Web'den okuma

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

0

Bu genel işlevi kullan

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
}

bu kod satırı ile:

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

bu tür için:

struct Model: Codable {
    let tall: Int
}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.