एक JSON फ़ाइल में स्विफ्ट का उपयोग करके पढ़ना

Question

मैं वास्तव में स्विफ्ट में एक JSON फ़ाइल पढ़ने की कोशिश कर रहा हूं ताकि मैं इसके साथ खेल सकूं। मैंने 2 दिनों का सबसे अच्छा हिस्सा फिर से खोज और विभिन्न तरीकों की कोशिश कर रहा है, लेकिन अभी तक कोई भाग्य नहीं है इसलिए मैंने StackOverFlow पर हस्ताक्षर किए हैं यह देखने के लिए कि क्या कोई मुझे सही दिशा में इंगित कर सकता है .....

मेरी JSON फ़ाइल को test.json कहा जाता है और इसमें निम्नलिखित शामिल हैं:

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

फ़ाइल सीधे दस्तावेजों में संग्रहीत की जाती है और मैं निम्नलिखित कोड का उपयोग करके इसे एक्सेस करता हूं:

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

अगर कोई मुझे सिर्फ सही दिशा में एक धक्का दे सकता है कि मैं JSON फाइल को कैसे डी-सीरियल कर सकता हूं और इसे एक सुलभ स्विफ्ट ऑब्जेक्ट में डाल सकता हूं तो मैं हमेशा आभारी रहूंगा!

सधन्यवाद,

Krivvenz।

Comments

त्रुटि पैरामीटर का उपयोग करें ...

— Matthias Bauch

कृपया वास्तविक, संकलन योग्य कोड पोस्ट करें। जैसा कि यह अब है, pathकेवल ifदायरे में दिखाई देता है , और जब आप इसे उपयोग करते हैं तो अनसुलझे होते हैं NSData(contentsOfFile, options, error); आपके पास enum नामों में टाइपो भी है।

— क्रेरी

मेरी एपीआई स्विफ्ट 3 के लिए पूरी तरह से अपडेट है: github.com/borchero/WebParsing

— borchero

यह कुंजी है -> "मान": "% LOAD VALUE FROM tmclass.json फ़ाइल%" और मुझे फ़ाइल से दूसरे JSON को पार्स करने की आवश्यकता है तो मैं SWIFT में इसे कैसे प्राप्त कर सकता हूं?

— मयूर शिंदे

Answer 1

नीचे दिए गए कोड का पालन करें:

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

सरणी "व्यक्ति" में मुख्य व्यक्ति के सभी डेटा शामिल होंगे। इसे लाने के लिए इरेट करें।

स्विफ्ट 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
      }
}

Comments

यह अधिक उपयोगी होगा यदि आपने बताया कि क्यों / कैसे यह प्रश्न में वर्णित समस्या को हल करता है, बजाय कोड का एक गुच्छा प्रस्तुत करने के।

— मार्टिन आर

हाय अभिषेक - आपके उत्तर के लिए धन्यवाद, लेकिन यह अभी भी काम नहीं करता है। यह एप्लिकेशन को निम्न त्रुटि के साथ क्रैश करने का कारण बनता है: 2014-06-25 16: 02: 04.146 एच एंड एस कैप्चर [4937: 131932] *** अनकहा अपवाद के कारण एप्लिकेशन समाप्त करना 'NSInvalidArgumentException', कारण, '*** - [_NSPlaceholderData initWithContentsOfFile: Options: error:]: nil फाइल तर्क '*** पहला फेंक कॉल स्टैक: इस पर कोई विचार क्यों? JsonData विकल्पों के लिए: मैंने (पथ, विकल्प: NSDataReadingOptions.DataReadingMappedIfSafe, त्रुटि: nil)

— Krivvenz

आपका फ़ाइल पथ सही नहीं है। इसके अतिरिक्त, आपके द्वारा निर्दिष्ट पथ पर test.json नामक कोई फ़ाइल नहीं है। कृपया फ़ाइल के सही स्थान की जाँच करें

— अभिषेक

"चलो jsonData = NSData.dataWithContentsOfFile (शून्य: .DataReadingMappedIfSafe, त्रुटि पथ, विकल्प)" के बदले "जाने jsonData = NSData (पथ contentsOfFile!)"

— टोंग

हालांकि कयामत के इस पिरामिड के बजाय यहां गार्ड के बयानों का उपयोग करना बेहतर है।

— जोनली नेम

Answer 2

अगर किसी को SwiftyJSON उत्तर की तलाश है:
अद्यतन: के
लिए 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.")
}

Comments

इसने मुझे swiftyJSON और Carthage में बदल दिया! धन्यवाद :)

— पॉल वैंड

मैंने इसका उपयोग केवल यह जानने के लिए किया कि इसमें ऑब्जेक्ट मैपिंग का अभाव है, मैं अगली बार एक अलग पुस्तकालय की कोशिश

— करूंगा

स्विफ्ट 3 में कॉपी पेस्ट त्रुटि से बचने के लिए: NSData और NSError डेटा और त्रुटि बन गया।

— सेल्वा

मैंने कुछ अलग तरीकों की कोशिश की और इसने स्विफ्ट 3 में मेरे लिए सबसे अच्छा काम किया

— crobicha

चूंकि MacOS 10.6 / iOS 4 (!) URL बनाने के लिए अतिरिक्त कदम से बचने के लिए API url(forResourceहै(NS)Bundle

— vadian

Answer 3

डिकोडेबल का उपयोग करके स्विफ्ट 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
}

स्विफ्ट 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
}

Comments

इसे नए दस्तावेज़ सुविधा में ले जाया जाना चाहिए, या सही उत्तर के रूप में चिह्नित किया जाना चाहिए।

— सिस्टम

Answer 4

Xcode 8 स्विफ्ट 3 फ़ाइल अपडेट से पढ़ें json:

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

Answer 5

स्विफ्ट 3.0 के लिए अद्यतित नाम

अभिषेक के जवाब और द्रुवा के जवाब पर आधारित

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
}

Answer 6

पीटर क्रेन्ज़ द्वारा प्रदान किए गए उदाहरण को सरल बनाना। स्विफ्ट 4.2 के साथ काम करता है।

विस्तार समारोह:

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

उदाहरण मॉडल:

struct Service: Decodable {
  let name: String
}

उदाहरण का उपयोग:

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

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

// use output if all good

उदाहरण सरणियों के साथ भी काम करेगा:

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

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

// use output if all good

ध्यान दें कि हम किसी भी अनावश्यक जेनरिक को कैसे प्रदान नहीं करते हैं, इस प्रकार हमें पार्स का परिणाम देने की आवश्यकता नहीं है।

Answer 7

स्विफ्ट 2.1 उत्तर (अभिषेक के आधार पर):

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

Answer 8

स्विफ्ट 3.0, एक्सकोड 8, आईओएस 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)")
        }
    }

आउटपुट:

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

Answer 9

इसने मेरे साथ बहुत अच्छा काम किया

func readjson(fileName: String) -> NSData{

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

    return jsonData!
}

Answer 10

यहाँ SwiftyJSON का उपयोग करके मेरा समाधान है

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

        let json = JSON(data: data)

    }
}

Answer 11

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
}

👆🏻 कॉपी-पेस्ट तैयार, तीसरा पक्ष फ्रेमवर्क स्वतंत्र समाधान।

उपयोग 👇🏻

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

Comments

यह मेरे लिए काम किया। मुझे एक ऐप में दवाओं की खोज योग्य सूची को हार्ड कोड करने की आवश्यकता थी। मुझे mySQL डेटाबेस से json फाइल मिली। मैंने अपने XCODE प्रोजेक्ट में json फ़ाइल को गिरा दिया, जो कि व्यूडलॉड और bam में ऊपर चल रहा था, मेरे पास मेरा json शब्दकोश था !!!

— ब्रायन

Answer 12

मैं एक और उत्तर प्रदान कर रहा हूं क्योंकि यहां कोई भी परीक्षण बंडल से संसाधन लोड करने की दिशा में सक्षम नहीं है। यदि आप एक दूरस्थ सेवा का उपभोग कर रहे हैं जो JSON को बाहर निकालती है और वास्तविक सेवा से टकराए बिना परिणाम का परीक्षण करने के लिए इकाई परीक्षण करना चाहती है, तो आप एक या एक से अधिक प्रतिक्रियाएं लेते हैं और उन्हें अपने प्रोजेक्ट में टेस्ट फ़ोल्डर में फ़ाइलों में डालते हैं।

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

यह SwiftyJSON का भी उपयोग करता है लेकिन परीक्षण बंडल प्राप्त करने और फ़ाइल लोड करने का मुख्य तर्क प्रश्न का उत्तर है।

Answer 13

स्विफ्ट 4: मेरे समाधान की कोशिश करें:

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

उदाहरण:

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

Comments

आपका fromJSONएक्सटेंशन फ़ंक्शन फेंकता है, फिर भी उदाहरण में आप इसे tryकीवर्ड के बिना कहते हैं । यह कोड संकलित नहीं करेगा।

— नेवरवर्टनमून

इसके अलावा, fromJSONआप के लिए एक Decodable एक्सटेंशन का उपयोग करें, फिर भी आप Decodable प्रकार से किसी भी जानकारी का उपयोग नहीं करते हैं, लेकिन अतिरिक्त (पूरी तरह से बेकार) जेनरिक प्रदान करते हैं।

— नेवरवर्टनमून

Answer 14

नवीनतम स्विफ्ट 3.0 बिल्कुल काम कर रहा है

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
    }

Answer 15

4 JSONके Classसाथ स्विफ्ट Decodable- उन लोगों के लिए जो कक्षाएं पसंद करते हैं

निम्नानुसार वर्गों को परिभाषित करें:

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
}

उपयोग, बहुत सार:

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

यह दोनों वर्गों Peopleऔर Personवर्गों, चर (विशेषताओं) के तरीकों की अनुमति देता है और privateयदि आवश्यक हो तो तरीकों को भी चिह्नित किया जा सकता है ।

Answer 16

निम्नलिखित कोड मेरे लिए काम करता है। मैं स्विफ्ट 5 का उपयोग कर रहा हूं

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

फिर, यदि आपकी व्यक्ति संरचना (या कक्षा) घटनीय है (और इसके सभी गुण भी), तो आप बस कर सकते हैं:

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

मैंने कोड को अधिक सुपाठ्य बनाने के लिए सभी त्रुटि हैंडलिंग कोड से परहेज किया।

Answer 17

सबसे सुरक्षित तरीके से स्विफ्ट 3 के लिए अपडेट किया गया

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

Answer 18

स्विफ्ट 5.1, एक्सकोड 11

आप इसका उपयोग कर सकते हैं:

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
}

Answer 19

अभिषेक के जवाब के आधार पर , 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

Comments

क्या आप स्विफ्ट 2.0 का उपयोग कर रहे हैं? फिर हां, यही मामला होगा। इसका उत्तर पूर्व 2.0 था।

— डेविड पॉक्सन

Answer 20

इसने मेरे लिए 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)
        }
    }
}

Answer 21

स्विफ्ट 4.1 अपडेटेड एक्सकोड 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
           }
 }

Comments

कुछ भी नया नहीं है, इसके विपरीत: NSDataस्विफ्ट 3+ में उपयोग न करें , और .allowFragmentsइस मामले में व्यर्थ है।

— vadian

Answer 22

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

Answer 23

मैंने परियोजना निर्देशिका में मौजूद FAQ-data.json फ़ाइल से JSON लाने के लिए नीचे दिए गए कोड का उपयोग किया है ।

मैं Xcode 7.3 में स्विफ्ट का उपयोग करके लागू कर रहा हूं।

     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 फ़ाइल की संरचना:

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

Answer 24

मैं रे वेंडरलिच के स्विफ्ट JSON ट्यूटोरियल (जिसमें भयानक SwiftyJSON वैकल्पिक, ग्लॉस भी शामिल है ) की सिफारिश कर सकता हूं । एक अंश (जो स्वयं दिया गया है, पूरी तरह से पोस्टर का उत्तर नहीं देता है, लेकिन इस उत्तर का जोड़ा मूल्य लिंक है, इसलिए नंबर -1 उसके लिए है, कृपया):

ऑब्जेक्टिव-सी में, JSON को पार्स करना और डिसेर्बलाइज़ करना काफी सरल है:

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

स्विफ्ट में, पार्सिंग और डिसेररलाइज़िंग JSON, स्विफ्ट ऑप्शंस और टाइप-सेफ्टी के कारण थोड़ा अधिक थकाऊ है [लेकिन] स्विफ्ट 2.0 के हिस्से के रूप में guardबयान नेस्टेड ifस्टेटमेंट से छुटकारा पाने में मदद के लिए पेश किया गया था :

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

बेशक, XCode 8.x में, आप केवल स्पेस बार को डबल-टैप करें और कहें "अरे, सिरी, कृपया इस JSON को मेरे लिए स्विफ्ट 3.0 में स्पेस / टैब-इंडेंट्स के साथ डिसेररलाइज करें।"

Answer 25

स्विफ्टजसन संस्करण स्विफ्ट 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
}

Answer 26

पहले इस तरह से एक Struc कोडेबल बनाएं:

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

अब चर घोषित करें

 var jzdosList = [JuzgadosList]()

मुख्य निर्देशिका से पढ़ें

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

वेब से पढ़ें

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

Answer 27

इस जेनेरिक फ़ंक्शन का उपयोग करें

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
}

कोड की इस पंक्ति के साथ:

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

इस प्रकार के लिए:

struct Model: Codable {
    let tall: Int
}