Ich habe eine JSON-Datei, möchte die Liste der Objekte in der Tabellenansicht analysieren und verwenden. Kann jemand den Code freigeben, um die JSON-Datei schnell zu analysieren?

Einfacher geht es nicht:

import Foundation

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

Trotzdem empfehle ich dringend, in Swift 4 eingeführte codierbare APIs zu verwenden .

API-Anfrage stellen

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

Vorbereitung auf die Antwort

Deklarieren Sie ein Array wie folgt

var data: NSMutableData = NSMutableData()

Antwort erhalten

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

   }
}

Wenn NSURLConnectionwir eine Antwort erhalten, können wir erwarten, dass die didReceiveResponseMethode in unserem Namen aufgerufen wird. An diesem Punkt setzen wir einfach unsere Daten zurück self.data = NSMutableData(), indem wir sagen , dass wir ein neues leeres Datenobjekt erstellen.

Nachdem eine Verbindung hergestellt wurde, werden wir Daten in der Methode empfangen didReceiveData. Das Datenargument, das hier übergeben wird, ist der Ursprung all unserer saftigen Informationen. Wir müssen an jedem eingehenden Block festhalten, also hängen wir ihn an das Objekt self.data an, das wir zuvor gelöscht haben.

Wenn die Verbindung hergestellt ist und alle Daten empfangen wurden, connectionDidFinishLoadingwird sie aufgerufen und wir sind bereit, die Daten in unserer App zu verwenden. Hurra!

Die connectionDidFinishLoadinghier verwendete Methode verwendet die NSJSONSerializationKlasse, um unsere Rohdaten in nützliche DictionaryObjekte umzuwandeln, indem die Ergebnisse aus Ihrer URL deserialisiert werden.

Ich habe gerade eine Klasse namens JSON geschrieben, die die JSON-Behandlung in Swift so einfach macht wie das JSON-Objekt in ES5.

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

Schalten Sie Ihr schnelles Objekt wie folgt in JSON um:

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

... oder String ...

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

... oder URL.

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

Durchlaufen Sie einfach Elemente per Index:

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

Genau wie bei SwiftyJSON machen Sie sich keine Sorgen, wenn der tiefgestellte Eintrag nicht vorhanden ist.

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

Wenn Sie die Indizes satt haben, fügen Sie Ihr Schema folgendermaßen hinzu:

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

Und du gehst:

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

Hoffe du magst es.

Mit dem neuen xCode 7.3+ ist es wichtig, Ihre Domain zur Ausnahmeliste hinzuzufügen ( Wie kann ich NSAppTransportSecurity zu meiner info.plist-Datei hinzufügen? ). Anweisungen finden Sie in diesem Beitrag. Andernfalls wird ein Transportberechtigungsfehler angezeigt.

Hier ist ein Code zum Durchführen der Konvertierungen zwischen JSON und NSData in Swift 2.0

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

Codierbar

In Swift 4+ wird dringend empfohlen, Codableanstelle von zu verwenden JSONSerialization.

Dies Codablebeinhaltet zwei Protokolle: Decodableund Encodable. Mit diesem DecodableProtokoll können Sie Dataim JSON-Format in eine benutzerdefinierte Struktur / Klasse dekodieren , die diesem Protokoll entspricht.

Stellen Sie sich zum Beispiel die Situation vor, dass wir diese einfache haben Data(Array von zwei Objekten)

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

dann folgendes structProtokoll haben und implementierenDecodable

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

Jetzt können Sie DataIhre Daten in Ihr Array dekodieren Person, JSONDecoderwobei der erste Parameter dem Typ entspricht, Decodableder diesem Typ entspricht, und dieser Typ sollte Datadekodiert werden

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

... beachten Sie, dass die Dekodierung mit einem trySchlüsselwort gekennzeichnet sein muss, da Sie beispielsweise einen Fehler bei der Benennung machen können und Ihr Modell dann nicht richtig dekodiert werden kann ... Sie sollten es also in den Do-Try-Catch-Block einfügen

Fälle, in denen json eingegeben wird, unterscheiden sich vom Namen der Eigenschaft:

• Wenn der Schlüssel mit snake_case benannt ist, können Sie die Decoder festlegen, keyDecodingStrategyzu convertFromSnakeCasedenen der Schlüssel von property_namein camelCase geändert wirdpropertyName

  let decoder = JSONDecoder()
  decoder.keyDecodingStrategy = .convertFromSnakeCase
  let people = try decoder.decode([Person].self, from: data)

• Wenn Sie einen eindeutigen Namen benötigen, können Sie Codierungsschlüssel in struct / class verwenden, in denen Sie den Namen des Schlüssels deklarieren

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

Ich habe auch eine kleine Bibliothek geschrieben, die sich auf die Zuordnung der JSON-Antwort zu einer Objektstruktur spezialisiert hat. Ich benutze intern die Bibliothek json-swift von David Owens. Vielleicht ist es für jemand anderen nützlich.

https://github.com/prine/ROJSONParser

Beispiel Employees.json

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

Als nächsten Schritt müssen Sie Ihr Datenmodell erstellen (EmplyoeeContainer und 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]
    }()
}

Um die Objekte aus der JSON-Antwort tatsächlich zuzuordnen, müssen Sie die Daten nur als Parameter im Konstruktor an die EmployeeContainer-Klasse übergeben. Es erstellt automatisch Ihr Datenmodell.

 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)

Die Konsolenausgabe sieht dann wie folgt aus:

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

SwiftJSONParse : Analysiere JSON wie einen Badass

Ganz einfach und leicht zu lesen!

Beispiel: das Wert "mrap"aus nicknamesals String aus dieser JSON - Antwort

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

Es nimmt Ihre JSON-Daten so NSDatawie sie sind, ohne dass eine Vorverarbeitung erforderlich ist.

let parser = JSONParser(jsonData)

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

Haftungsausschluss: Ich habe das gemacht und hoffe, es hilft allen. Fühlen Sie sich frei, es zu verbessern!

Das Parsen von JSON in Swift ist eine hervorragende Aufgabe für die Codegenerierung. Ich habe unter http://www.guideluxe.com/JsonToSwift ein Tool erstellt , um genau das zu tun.

Sie geben ein Beispiel-JSON-Objekt mit einem Klassennamen an, und das Tool generiert eine entsprechende Swift-Klasse sowie alle erforderlichen untergeordneten Swift-Klassen, um die durch das Beispiel-JSON implizierte Struktur darzustellen. Ebenfalls enthalten sind Klassenmethoden, die zum Auffüllen von Swift-Objekten verwendet werden, einschließlich einer Methode, die die NSJSONSerialization.JSONObjectWithData-Methode verwendet. Die erforderlichen Zuordnungen von den NSArray- und NSDictionary-Objekten werden bereitgestellt.

Aus dem generierten Code müssen Sie nur ein NSData-Objekt angeben, das JSON enthält und mit dem dem Tool bereitgestellten Beispiel übereinstimmt.

Außer Foundation gibt es keine Abhängigkeiten.

Meine Arbeit wurde von http://json2csharp.com/ inspiriert , was für .NET-Projekte sehr praktisch ist.

So erstellen Sie ein NSData-Objekt aus einer JSON-Datei.

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

1. Installieren Sie Swifty Json

Hinweis: Wenn Sie danach suchen, besteht auch eine hohe Wahrscheinlichkeit, dass Sie nicht wissen, wie Sie installieren sollen swifty. Folgen Sie den Anweisungen hier .

sudo gem install cocoapods

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

Geben Sie als nächstes diesen Befehl ein:

pod init

Dadurch wird ein Standard Podfilefür Ihr Projekt erstellt. Hier Podfiledefinieren Sie die Abhängigkeiten, auf die sich Ihr Projekt stützt.

Geben Sie diesen Befehl zum Öffnen Podfilemit Xcodefür die Bearbeitung:

open -a Xcode Podfile

Fügen Sie das Swiftyin die Poddatei ein

platform :ios, '8.0'
use_frameworks!

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

2. Überprüfen Sie dieses Beispiel

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

Der gesamte Viewcontroller, der Daten in der Sammlungsansicht mit zwei Methoden von json parsig anzeigt

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

Verwenden des ObjectMapper-Frameworks

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

Bevor Sie den Satz geeigneter: Zuordnbarer Objekte zum Parsen vorbereiten sollten

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

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

Daten - es ist Datentyp (Struktur) (dh von einer Serverantwort zurückgegeben)

Dieser Parser verwendet Generika, um JSON in Swift-Typen umzuwandeln, wodurch der Code, den Sie eingeben müssen, reduziert wird.

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

Unten sehen Sie ein Beispiel für einen schnellen Spielplatz:

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

Swift 4

Erstellen Sie ein Projekt

Entwerfen Sie StoryBoard mit einem Button und einer UITableview

Erstellen Sie TableViewCell VC

Fügen Sie in Button Action die folgenden Codes ein

Denken Sie an diesen Code zum Abrufen von Datenarrays in einer 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
    }
}

Dies ist für das Abrufen von Wörterbuchdaten vorgesehen

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

Swift 4 API-Anforderungsbeispiel

Gebrauch machen von JSONDecoder().decode

Sehen Sie sich dieses Video an, in dem JSON mit Swift 4 analysiert wird

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

Swift 2 iOS 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)
}