JSON फ़ाइल को स्विफ्ट में पार्स कैसे करें?

Question 1

मेरे पास एक JSON फ़ाइल है, तालिका दृश्य में वस्तुओं की सूची को पार्स और उपयोग करना चाहते हैं। क्या कोई भी JSON फाइल को स्विफ्ट में पार्स करने के लिए कोड साझा कर सकता है।

Question 2

अधिक सरल नहीं हो सकता है:

import Foundation

let jsonData: Data = /* get your json data */
let jsonDict = try JSONSerialization.jsonObject(with: jsonData) as? NSDictionary

कहा जा रहा है कि, मैं स्विफ्ट 4 में पेश कोडेबल एपीआई का उपयोग करने की दृढ़ता से सलाह देता हूं ।

Question 3

एपीआई अनुरोध करना

var request: NSURLRequest = NSURLRequest(URL: url)
var connection: NSURLConnection = NSURLConnection(request: request, delegate: self, startImmediately: false)

प्रतिक्रिया के लिए तैयारी कर रहा है

नीचे के रूप में एक सरणी घोषित करें

var data: NSMutableData = NSMutableData()

प्रतिक्रिया प्राप्त करना

1।

func connection(didReceiveResponse: NSURLConnection!, didReceiveResponse response: NSURLResponse!) {
   // Received a new request, clear out the data object
   self.data = NSMutableData()
}

2।

func connection(connection: NSURLConnection!, didReceiveData data: NSData!) {
   // Append the received chunk of data to our data object
   self.data.appendData(data)
}

3।

func connectionDidFinishLoading(connection: NSURLConnection!) {
   // Request complete, self.data should now hold the resulting info
   // Convert the retrieved data in to an object through JSON deserialization
   var err: NSError
   var jsonResult: NSDictionary = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.MutableContainers, error: nil) as NSDictionary

   if jsonResult.count>0 && jsonResult["results"].count>0 {
      var results: NSArray = jsonResult["results"] as NSArray
      self.tableData = results
      self.appsTableView.reloadData()

   }
}

जब NSURLConnectionकोई प्रतिक्रिया मिलती है, तो हम didReceiveResponseअपनी ओर से बुलाए जाने वाले तरीके की अपेक्षा कर सकते हैं । इस बिंदु पर हम केवल self.data = NSMutableData()एक नया खाली डेटा ऑब्जेक्ट बनाते हुए , कहकर अपना डेटा रीसेट करते हैं ।

एक कनेक्शन किए जाने के बाद, हम विधि में डेटा प्राप्त करना शुरू करेंगे didReceiveData । डेटा तर्क यहां से पारित किया जा रहा है, जहां हमारी सभी रसदार जानकारी आती है। हमें प्रत्येक चैंक पर आने की आवश्यकता है, इसलिए हम इसे उस self.data ऑब्जेक्ट में जोड़ते हैं जिसे हमने पहले साफ़ किया था।

अंत में, जब कनेक्शन हो गया है और सभी डेटा प्राप्त हो गए हैं, connectionDidFinishLoading कहा जाता है और हम अपने ऐप में डेटा का उपयोग करने के लिए तैयार हैं। हुर्रे!

यहां connectionDidFinishLoadingविधि आपके Url से परिणामों को डीरियलाइज़ करके NSJSONSerializationहमारे कच्चे डेटा को उपयोगी Dictionaryवस्तुओं में बदलने के लिए कक्षा का उपयोग करती है ।

Question 4

मैंने सिर्फ JSON नामक एक क्लास लिखी है, जो JSON ऑब्जेक्ट को ES5 में आसान बनाने के लिए स्विफ्ट में JSON हैंडल करता है।

https://github.com/dankogai/swift-json/

अपनी त्वरित वस्तु को JSON की तरह मोड़ें:

let obj:[String:AnyObject] = [
    "array": [JSON.null, false, 0, "",[],[:]],
    "object":[
        "null":   JSON.null,
        "bool":   true,
        "int":    42,
        "double": 3.141592653589793,
        "string": "a α\t弾\n𪚲",
        "array":  [],
        "object": [:]
    ],
    "url":"http://blog.livedoor.com/dankogai/"
]

let json = JSON(obj)
json.toString()

... या स्ट्रिंग ...

let json = JSON.parse("{\"array\":[...}")

... या URL।

let json = JSON.fromURL("http://api.dan.co.jp/jsonenv")
Tree Traversal

सबस्क्रिप्ट के माध्यम से केवल मूल तत्व:

json["object"]["null"].asNull       // NSNull()
// ...
json["object"]["string"].asString   // "a α\t弾\n𪚲"
json["array"][0].asNull             // NSNull()
json["array"][1].asBool             // false
// ...

स्विफ्टजैन्स की तरह ही यदि आप उपप्रवेशित प्रविष्टि मौजूद नहीं हैं, तो आप चिंता न करें।

if let b = json["noexistent"][1234567890]["entry"].asBool {
    // ....
} else {
    let e = json["noexistent"][1234567890]["entry"].asError
    println(e)
}

यदि आप सदस्यता से थक चुके हैं, तो अपनी योजना को इस तरह जोड़ें:

//// schema by subclassing
class MyJSON : JSON {
    init(_ obj:AnyObject){ super.init(obj) }
    init(_ json:JSON)  { super.init(json) }
    var null  :NSNull? { return self["null"].asNull }
    var bool  :Bool?   { return self["bool"].asBool }
    var int   :Int?    { return self["int"].asInt }
    var double:Double? { return self["double"].asDouble }
    var string:String? { return self["string"].asString }
}

और तुम जाओ:

let myjson = MyJSON(obj)
myjson.object.null
myjson.object.bool
myjson.object.int
myjson.object.double
myjson.object.string
// ...

उम्मीद है आप इसे पसंद करते हैं।

नए xCode 7.3+ के साथ अपने डोमेन को अपवाद सूची में जोड़ना महत्वपूर्ण है ( मैं अपनी जानकारी के लिए NSAppTransportSecurity कैसे जोड़ सकता हूं? ), निर्देश के लिए इस पोस्टिंग को देखें, अन्यथा आपको परिवहन प्राधिकरण त्रुटि मिलेगी।

Question 5

यहां स्विफ्ट 2.0 में JSON और NSData के बीच रूपांतरण करने के लिए एक कोड है

// Convert from NSData to json object
func nsdataToJSON(data: NSData) -> AnyObject? {
    do {
        return try NSJSONSerialization.JSONObjectWithData(data, options: .MutableContainers)
    } catch let myJSONError {
        print(myJSONError)
    }
    return nil
}

// Convert from JSON to nsdata
func jsonToNSData(json: AnyObject) -> NSData?{
    do {
        return try NSJSONSerialization.dataWithJSONObject(json, options: NSJSONWritingOptions.PrettyPrinted)
    } catch let myJSONError {
        print(myJSONError)
    }
    return nil;
}

Question 6

Codable

स्विफ्ट में 4+ के Codableबजाय उपयोग करने के लिए दृढ़ता से अनुशंसा की जाती है JSONSerialization।

यह Codableदो प्रोटोकॉल में शामिल हैं: Decodableऔर Encodable। यह Decodableप्रोटोकॉल आपको DataJSON प्रारूप में इस प्रोटोकॉल के अनुरूप कस्टम संरचना / वर्ग में डिकोड करने की अनुमति देता है।

उदाहरण के लिए ऐसी स्थिति की कल्पना करें कि हमारे पास यह सरल है Data(दो वस्तुओं का सरणी)

let data = Data("""
[
    {"name":"Steve","age":56}, 
    {"name":"iPhone","age":11}
]
""".utf8)

इसके बाद structप्रोटोकॉल का पालन और कार्यान्वयन करना हैDecodable

struct Person: Decodable {
    let name: String
    let age: Int
}

अब आप अपने उपयोग Dataकी अपनी सरणी को डीकोड कर सकते हैं जहां पहला पैरामीटर टाइप के अनुरूप है और इस प्रकार को डिकोड किया जाना चाहिएPersonJSONDecoderDecodableData

do {
    let people = try JSONDecoder().decode([Person].self, from: data)
} catch { print(error) }

... ध्यान दें कि डिकोडिंग को tryकीवर्ड के साथ चिह्नित करना होगा क्योंकि आप उदाहरण के लिए नामकरण के साथ कुछ गलती कर सकते हैं और फिर आपके मॉडल को सही ढंग से डिकोड नहीं किया जा सकता ... इसलिए आपको इसे डू-ट्राइ-कैच ब्लॉक के अंदर डालना चाहिए

JSON में महत्वपूर्ण मामले संपत्ति के नाम से भिन्न हैं:

कुंजी में snake_case का उपयोग कर के नाम पर है, तो आप के डिकोडर सेट कर सकते हैं keyDecodingStrategyकरने के लिए convertFromSnakeCaseसे बदलता है जो कुंजी property_nameCamelCase कोpropertyName
```
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let people = try decoder.decode([Person].self, from: data)
```
यदि आपको अद्वितीय नाम की आवश्यकता है, तो आप संरचना / वर्ग के अंदर कोडिंग कुंजी का उपयोग कर सकते हैं जहां आप कुंजी का नाम घोषित करते हैं
```
let data = Data(""" 
{ "userName":"Codable", "age": 1 } 
""".utf8)

struct Person: Decodable {

    let name: String
    let age: Int

    enum CodingKeys: String, CodingKey {
        case name = "userName"
        case age
    }
}
```

Question 7

मैंने एक छोटी सी लाइब्रेरी भी लिखी थी जो किसी ऑब्जेक्ट स्ट्रक्चर में जौनस रिस्पॉन्स की मैपिंग के लिए विशेष है। मैं डेविड ओवेन्स से लाइब्रेरी जोंस-स्विफ्ट का आंतरिक रूप से उपयोग कर रहा हूं। शायद यह किसी और के लिए उपयोगी है।

https://github.com/prine/ROJSONParser

उदाहरण Employees.json

{
"employees": [
  {
    "firstName": "John",
    "lastName": "Doe",
    "age": 26
  },
  {
    "firstName": "Anna",
    "lastName": "Smith",
    "age": 30
  },
  {
    "firstName": "Peter",
    "lastName": "Jones",
    "age": 45
  }]
}

अगले चरण के रूप में आपको अपना डेटा मॉडल (EmplyoeeContainer और Employee) बनाना होगा।

Employee.swift

class Employee : ROJSONObject {

    required init() {
        super.init();
    }

    required init(jsonData:AnyObject) {
        super.init(jsonData: jsonData)
    }

    var firstname:String {
        return Value<String>.get(self, key: "firstName")
    }

    var lastname:String {
        return Value<String>.get(self, key: "lastName")            
    }

    var age:Int {
        return Value<Int>.get(self, key: "age")
    }
}

EmployeeContainer.swift

class EmployeeContainer : ROJSONObject {
    required init() {
        super.init();
    }

    required init(jsonData:AnyObject) {
        super.init(jsonData: jsonData)
    }

    lazy var employees:[Employee] = {
        return Value<[Employee]>.getArray(self, key: "employees") as [Employee]
    }()
}

फिर वास्तव में JSON प्रतिक्रिया से ऑब्जेक्ट्स को मैप करने के लिए आपको केवल कंस्ट्रक्टर में कर्मचारी के रूप में EmployeeContainer वर्ग में डेटा पास करना होगा। यह आपके डेटा मॉडल को स्वचालित रूप से बनाता है।

 var baseWebservice:BaseWebservice = BaseWebservice();

  var urlToJSON = "http://prine.ch/employees.json"

  var callbackJSON = {(status:Int, employeeContainer:EmployeeContainer) -> () in
    for employee in employeeContainer.employees {
      println("Firstname: \(employee.firstname) Lastname: \(employee.lastname) age: \(employee.age)")
    }
  }

  baseWebservice.get(urlToJSON, callback:callbackJSON)

कंसोल आउटपुट तब निम्न की तरह दिखता है:

Firstname: John Lastname: Doe age: 26
Firstname: Anna Lastname: Smith age: 30
Firstname: Peter Lastname: Jones age: 45

Question 8

SwiftJSONParse : पार्स जोंसन एक बदमाश की तरह

मृत-सरल और पढ़ने में आसान!

उदाहरण: मान प्राप्त `"mrap"`से `nicknames`इस JSON प्रतिक्रिया से एक स्ट्रिंग के रूप में

{
    "other": {
        "nicknames": ["mrap", "Mikee"]
}

यह आपके जसन डेटा NSDataको लेता है, यह प्रीप्रोसेस करने की आवश्यकता नहीं है।

let parser = JSONParser(jsonData)

if let handle = parser.getString("other.nicknames[0]") {
    // that's it!
}

डिस्क्लेमर: मैंने इसे बनाया है और मुझे उम्मीद है कि यह सभी की मदद करेगा। इस पर सुधार करने के लिए स्वतंत्र महसूस करें!

Question 9

स्विफ्ट में पार्सिंग JSON कोड पीढ़ी के लिए एक उत्कृष्ट काम है। मैंने http://www.guideluxe.com/JsonToSwift पर एक टूल बनाया है।

आप क्लास नाम के साथ एक नमूना JSON ऑब्जेक्ट की आपूर्ति करते हैं और उपकरण JSON द्वारा निहित संरचना का प्रतिनिधित्व करने के लिए एक संबंधित स्विफ्ट क्लास, साथ ही किसी भी आवश्यक सहायक स्विफ्ट कक्षाएं उत्पन्न करेगा। इसमें शामिल हैं स्विफ्ट ऑब्जेक्ट्स को पॉप्युलेट करने के लिए उपयोग की जाने वाली क्लास मेथड्स, जिसमें NSJSONSerialization.JSONObjectWithData मेथड का उपयोग किया जाता है। NSArray और NSDictionary वस्तुओं से आवश्यक मैपिंग प्रदान की जाती हैं।

उत्पन्न कोड से, आपको केवल JSON युक्त NSData ऑब्जेक्ट की आपूर्ति करने की आवश्यकता है जो उपकरण को प्रदान किए गए नमूने से मेल खाती है।

फाउंडेशन के अलावा, कोई निर्भरता नहीं हैं।

मेरा काम http://json2csharp.com/ से प्रेरित था , जो .NET प्रोजेक्ट्स के लिए बहुत उपयोगी है।

यहां JSON फ़ाइल से NSData ऑब्जेक्ट बनाने का तरीका बताया गया है।

let fileUrl: NSURL = NSBundle.mainBundle().URLForResource("JsonFile", withExtension: "json")!
let jsonData: NSData = NSData(contentsOfURL: fileUrl)!

Question 10

Swifty Json स्थापित करें

नोट: यदि आप इसे ढूंढ रहे हैं, तो एक उच्च संभावना भी है कि आप नहीं जानते कि कैसे स्थापित करें swifty। यहां दिए गए निर्देशों का पालन करें ।

sudo gem install cocoapods

cd ~/Path/To/Folder/Containing/ShowTracker

अगला इस कमांड में दर्ज करें:

pod init

यह Podfileआपके प्रोजेक्ट के लिए एक डिफ़ॉल्ट बना देगा । वह जगह Podfileहै जहाँ आप अपनी परियोजना पर निर्भर निर्भरता को परिभाषित करते हैं।

संपादन के लिए Podfileउपयोग करने के Xcodeलिए इस कमांड को टाइप करें :

open -a Xcode Podfile

Swiftyपोडफाइल में जोड़ें

platform :ios, '8.0'
use_frameworks!

target 'MyApp' do
    pod 'SwiftyJSON', '~> X.X.X'
end

इस उदाहरण की जाँच करें

var mURL = NSURL(string: "http://api.openweathermap.org/data/2.5/weather?q=London,uk&units=metric")

if mURL == nil{
    println("You are stupid")
    return
}

var request = NSURLRequest(URL: mURL!)

NSURLConnection.sendAsynchronousRequest(
    request,
    queue: NSOperationQueue.mainQueue(),
    completionHandler:{ (
        response: NSURLResponse!, 
        data: NSData!, 
        error: NSError!) -> Void in

    if data != nil {

        var mJSON = JSON(data: data!)

        if let current_conditions = mJSON["weather"][0]["description"].string {
            println("Current conditions: " + current_conditions)
        } else {
            println("MORON!")
        }

        if let current_temperature = mJSON["main"]["temp"].double {
            println("Temperature: "+ String(format:"%.f", current_temperature)  + "°C"
        } else {
            println("MORON!")
        }
    }
})

Question 11

संपूर्ण व्यू-कंट्रोलर जो जॅन्स पार्सिग के दो तरीकों का उपयोग करके बोलचाल के दृश्य में डेटा दिखाते हैं

@IBOutlet weak var imagecollectionview: UICollectionView!
lazy var data = NSMutableData()
var dictdata : NSMutableDictionary = NSMutableDictionary()
override func viewDidLoad() {
    super.viewDidLoad()
    startConnection()
    startNewConnection()
    // Do any additional setup after loading the view, typically from a nib.
}


func collectionView(collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
    return dictdata.count
}
func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {

    let cell  = collectionView.dequeueReusableCellWithReuseIdentifier("CustomcellCollectionViewCell", forIndexPath: indexPath) as! CustomcellCollectionViewCell
    cell.name.text = dictdata.valueForKey("Data")?.valueForKey("location") as? String
    let url = NSURL(string: (dictdata.valueForKey("Data")?.valueForKey("avatar_url") as? String)! )

    LazyImage.showForImageView(cell.image, url:"URL
    return cell
}
func collectionView(collectionView: UICollectionView,
                    layout collectionViewLayout: UICollectionViewLayout,
                           sizeForItemAtIndexPath indexPath: NSIndexPath) -> CGSize {
    let kWhateverHeightYouWant = 100
    return CGSizeMake(self.view.bounds.size.width/2, CGFloat(kWhateverHeightYouWant))
}

func startNewConnection()
{

   let url: URL = URL(string: "YOUR URL" as String)!
    let session = URLSession.shared

    let request = NSMutableURLRequest(url: url as URL)
    request.httpMethod = "GET" //set the get or post according to your request

    //        request.cachePolicy = NSURLRequest.CachePolicy.ReloadIgnoringCacheData
    request.cachePolicy = NSURLRequest.CachePolicy.reloadIgnoringCacheData

    let task = session.dataTask(with: request as URLRequest) {
        ( data, response, error) in

        guard let _:NSData = data as NSData?, let _:URLResponse = response, error == nil else {
            print("error")
            return
        }

       let jsonString = NSString(data: data!, encoding:String.Encoding.utf8.rawValue) as! String
               }
    task.resume()

}

func startConnection(){
    let urlPath: String = "your URL"
    let url: NSURL = NSURL(string: urlPath)!
    var request: NSURLRequest = NSURLRequest(URL: url)
    var connection: NSURLConnection = NSURLConnection(request: request, delegate: self, startImmediately: false)!
    connection.start()
}

func connection(connection: NSURLConnection!, didReceiveData data: NSData!){
    self.data.appendData(data)
}

func buttonAction(sender: UIButton!){
    startConnection()
}

func connectionDidFinishLoading(connection: NSURLConnection!) {
    do {
        let JSON = try NSJSONSerialization.JSONObjectWithData(self.data, options:NSJSONReadingOptions(rawValue: 0))
        guard let JSONDictionary :NSDictionary = JSON as? NSDictionary else {
            print("Not a Dictionary")
            // put in function
            return
        }
        print("JSONDictionary! \(JSONDictionary)")
        dictdata.setObject(JSONDictionary, forKey: "Data")

        imagecollectionview.reloadData()
    }
    catch let JSONError as NSError {
        print("\(JSONError)")
    }    }

Question 12

ObjectMapper ढांचे का उपयोग करना

if let path = Bundle(for: BPPView.self).path(forResource: jsonFileName, ofType: "json") {
    do {
        let data = try Data(contentsOf: URL(fileURLWithPath: path), options: NSData.ReadingOptions.mappedIfSafe)
        let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
        self.levels = Mapper<Level>().mapArray(JSONArray: (json as! [[String : Any]]))!
        print(levels.count)
    } catch let error as NSError {
        print(error.localizedDescription)
    }
} else {
    print("Invalid filename/path.")
}

इससे पहले कि आप उपयुक्त का सेट तैयार करें: अनुपयोगी वस्तुओं को पार्स करने के लिए

import UIKit 
import ObjectMapper
class Level: Mappable {
var levelName = ""
var levelItems = [LevelItem]()

required init?(map: Map) {

}

// Mappable
func mapping(map: Map) {
    levelName <- map["levelName"]
    levelItems <- map["levelItems"]
}

 import UIKit 
import ObjectMapper 
class LevelItem: Mappable {
var frontBackSide = BPPFrontBack.Undefined
var fullImageName = ""
var fullImageSelectedName = ""
var bodyParts = [BodyPart]()

required init?(map: Map) {

}

// Mappable
func mapping(map: Map) {
    frontBackSide <- map["frontBackSide"]
    fullImageName <- map["fullImageName"]
    fullImageSelectedName <- map["fullImageSelectedName"]
    bodyParts <- map["bodyParts"]
}}

Question 13

स्विफ्ट 3

let parsedResult: [String: AnyObject]
do {      
    parsedResult = try JSONSerialization.jsonObject(with: data, options: .allowFragments) as! [String:AnyObject]       
} catch {        
    // Display an error or return or whatever
}

डेटा - यह डेटा प्रकार (संरचना) है (अर्थात कुछ सर्वर प्रतिक्रिया द्वारा लौटाया गया)

Question 14

यह पार्सर जेन्सन को स्विफ्ट प्रकारों को देने के लिए जेनेरिक का उपयोग करता है जो आपके द्वारा टाइप किए जाने वाले कोड को कम करता है।

https://github.com/evgenyneu/JsonSwiftson

struct Person {
  let name: String?
  let age: Int?
}

let mapper = JsonSwiftson(json: "{ \"name\": \"Peter\", \"age\": 41 }")

let person: Person? = Person(
  name: mapper["name"].map(),
  age: mapper["age"].map()
)

Question 15

नीचे एक स्विफ्ट प्लेग्राउंड उदाहरण है:

import UIKit

let jsonString = "{\"name\": \"John Doe\", \"phone\":123456}"

let data = jsonString.data(using: .utf8)

var jsonObject: Any
do {
    jsonObject = try JSONSerialization.jsonObject(with: data!) as Any

    if let obj = jsonObject as? NSDictionary {
        print(obj["name"])
    }
} catch {
    print("error")
}

Question 16

स्विफ्ट 4

एक प्रोजेक्ट बनाएं

एक बटन और एक UITableview के साथ डिजाइन स्टोरीबोर्ड

TableViewCell वीसी बनाएं

बटन एक्शन में फ़ोलोइंग कोड डालें

एक Api में डेटा के लटके सरणी के लिए इस कोड को याद रखें

import UIKit

class ViewController3: UIViewController,UITableViewDelegate,UITableViewDataSource {

    @IBOutlet var tableView: UITableView!
    var displayDatasssss = [displyDataClass]()
    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }
    func numberOfSections(in tableView: UITableView) -> Int {
        return 1
    }
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return displayDatasssss.count
    }
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "TableViewCell1") as! TableViewCell1
        cell.label1.text = displayDatasssss[indexPath.row].email
        return cell
    }
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    @IBAction func gettt(_ sender: Any) {

        let url = "http://jsonplaceholder.typicode.com/users"
        var request = URLRequest(url: URL(string: url)!)
        request.httpMethod = "GET"
        let configuration = URLSessionConfiguration.default
        let session = URLSession(configuration: configuration, delegate: nil, delegateQueue: OperationQueue.main)
        let task = session.dataTask(with: request){(data, response,error)in
            if (error != nil){
                print("Error")
            }
            else{
                do{
                    // Array of Data 
                    let fetchData = try JSONSerialization.jsonObject(with: data!, options: .mutableLeaves) as! NSArray

                    for eachData in fetchData {

                        let eachdataitem = eachData as! [String : Any]
                        let name = eachdataitem["name"]as! String
                        let username = eachdataitem["username"]as! String

                        let email = eachdataitem["email"]as! String
                         self.displayDatasssss.append(displyDataClass(name: name, username: username,email : email))
                    }
                    self.tableView.reloadData()
                }
                catch{
                    print("Error 2")
                }

            }
        }
        task.resume()

    }
}
class displyDataClass {
    var name : String
    var username : String
    var email : String

    init(name : String,username : String,email :String) {
        self.name = name
        self.username = username
        self.email = email
    }
}

यह डिक्शनरी डेटा लास्टिंग के लिए है

import UIKit

class ViewController3: UIViewController,UITableViewDelegate,UITableViewDataSource {

    @IBOutlet var tableView: UITableView!
    var displayDatasssss = [displyDataClass]()
    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }
    func numberOfSections(in tableView: UITableView) -> Int {
        return 1
    }
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return displayDatasssss.count
    }
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "TableViewCell1") as! TableViewCell1
        cell.label1.text = displayDatasssss[indexPath.row].email
        return cell
    }
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    @IBAction func gettt(_ sender: Any) {

        let url = "http://jsonplaceholder.typicode.com/users/1"
        var request = URLRequest(url: URL(string: url)!)
        request.httpMethod = "GET"
        let configuration = URLSessionConfiguration.default
        let session = URLSession(configuration: configuration, delegate: nil, delegateQueue: OperationQueue.main)
        let task = session.dataTask(with: request){(data, response,error)in
            if (error != nil){
                print("Error")
            }
            else{
                do{
                    //Dictionary data Fetching
                    let fetchData = try JSONSerialization.jsonObject(with: data!, options: .mutableLeaves) as! [String: AnyObject]
                        let name = fetchData["name"]as! String
                        let username = fetchData["username"]as! String

                        let email = fetchData["email"]as! String
                         self.displayDatasssss.append(displyDataClass(name: name, username: username,email : email))

                    self.tableView.reloadData()
                }
                catch{
                    print("Error 2")
                }

            }
        }
        task.resume()

    }
}
class displyDataClass {
    var name : String
    var username : String
    var email : String

    init(name : String,username : String,email :String) {
        self.name = name
        self.username = username
        self.email = email
    }
}

Question 17

स्विफ्ट 4 एपीआई अनुरोध उदाहरण

उपयोग करना JSONDecoder().decode

इस वीडियो को देखें JSON ने स्विफ्ट 4 के साथ पार्स किया

struct Post: Codable {
    let userId: Int
    let id: Int
    let title: String
    let body: String
}

URLSession.shared.dataTask(with: URL(string: "https://jsonplaceholder.typicode.com/posts")!) { (data, response, error) in

    guard let response = response as? HTTPURLResponse else {
        print("HTTPURLResponse error")
        return
    }

    guard 200 ... 299 ~= response.statusCode else {
        print("Status Code error \(response.statusCode)")
        return
    }

    guard let data = data else {
        print("No Data")
        return
    }

    let posts = try! JSONDecoder().decode([Post].self, from: data)
    print(posts)      
}.resume()

Question 18

स्विफ्ट 2 आईओएस 9

let miadata = NSData(contentsOfURL: NSURL(string: "https://myWeb....php")!)

do{
    let MyData = try NSJSONSerialization.JSONObjectWithData(miadata!, options: NSJSONReadingOptions.MutableContainers) as? NSArray
    print(".........\(MyData)")    
}
catch let error as NSError{
    // error.description
    print(error.description)
}

JSON फ़ाइल को स्विफ्ट में पार्स कैसे करें?

Codable

SwiftJSONParse : पार्स जोंसन एक बदमाश की तरह

उदाहरण: मान प्राप्त "mrap"से nicknamesइस JSON प्रतिक्रिया से एक स्ट्रिंग के रूप में

स्विफ्ट 4 एपीआई अनुरोध उदाहरण

उदाहरण: मान प्राप्त `"mrap"`से `nicknames`इस JSON प्रतिक्रिया से एक स्ट्रिंग के रूप में