Eu tenho um arquivo JSON, quero analisar e usar a lista de objetos no modo de exibição de tabela. Qualquer um pode compartilhar o código para analisar o arquivo JSON rapidamente.

Não poderia ser mais simples:

import Foundation

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

Dito isso, eu recomendo fortemente o uso de APIs codificáveis introduzidas no Swift 4.

Fazendo a solicitação de API

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

Preparando-se para a resposta

Declare uma matriz como abaixo

var data: NSMutableData = NSMutableData()

Recebendo a resposta

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

   }
}

Ao NSURLConnectionreceber uma resposta, podemos esperar que o didReceiveResponsemétodo seja chamado em nosso nome. Neste ponto, simplesmente redefinimos nossos dados dizendoself.data = NSMutableData() , criando um novo objeto de dados vazio.

Depois que uma conexão for feita, começaremos a receber dados no método didReceiveData . O argumento de dados transmitido aqui é de onde vêm todas as nossas informações interessantes. Precisamos nos agarrar a cada fragmento que chega, então o acrescentamos ao objeto self.data que limpamos anteriormente.

Por fim, quando a conexão é feita e todos os dados foram recebidos, connectionDidFinishLoadingé chamado e estamos prontos para usar os dados em nosso aplicativo. Hooray!

O connectionDidFinishLoadingmétodo aqui usa oNSJSONSerialization classe para converter nossos dados brutos em Dictionaryobjetos úteis desserializando os resultados de seu Url.

Acabei de escrever uma classe chamada JSON, que torna o manuseio de JSON no Swift tão fácil quanto o objeto JSON no ES5.

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

Transforme seu objeto swift em JSON assim:

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

... ou string ...

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

... ou URL.

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

Basta percorrer os elementos por meio do subscrito:

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

Assim como o SwiftyJSON, você não se preocupe se a entrada subscrita não existir.

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

Se você está cansado de subscritos, adicione seu esquema assim:

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

E você vai:

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

Espero que você goste.

Com o novo xCode 7.3+, é importante adicionar seu domínio à lista de exceções ( como posso adicionar NSAppTransportSecurity ao meu arquivo info.plist? ), Consulte esta postagem para obter instruções, caso contrário, você receberá um erro de autoridade de transporte.

Aqui está um código para fazer as conversões entre JSON e NSData em 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;
}

Codificável

Em Swift 4+ é altamente recomendável usar em Codablevez de JSONSerialization.

Isso Codableinclui dois protocolos: Decodablee Encodable. Este Decodableprotocolo permite que você decodifiqueData no formato JSON para uma estrutura / classe personalizada em conformidade com este protocolo.

Por exemplo, imagine a situação em que temos este simples Data(array de dois objetos)

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

então siga structe implemente o protocoloDecodable

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

agora você pode decodificar seu Datapara sua matriz de Personuso JSONDecoderonde o primeiro parâmetro é o tipo em conformidade Decodablee para este tipo deve Dataser decodificado

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

... note que a decodificação deve ser marcada com uma trypalavra - chave já que você pode, por exemplo, cometer algum erro com a nomenclatura e então seu modelo não pode ser decodificado corretamente ... então você deve colocá-lo dentro do bloco do-try-catch

Casos em que a chave em json é diferente do nome da propriedade:

• Se a chave for nomeada usando snake_case, você pode definir o decodificador keyDecodingStrategypara o convertFromSnakeCasequal muda a chave de property_namepara camelCasepropertyName

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

• Se você precisar de um nome único, você pode usar chaves de codificação dentro de struct / classe onde você declara o nome da chave

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

Também escrevi uma pequena biblioteca especializada no mapeamento da resposta json em uma estrutura de objeto. Estou usando internamente a biblioteca json-swift de David Owens. Talvez seja útil para outra pessoa.

https://github.com/prine/ROJSONParser

Exemplo Employees.json

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

Na próxima etapa, você deve criar seu modelo de dados (EmplyoeeContainer e 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]
    }()
}

Então, para realmente mapear os objetos da resposta JSON, você só precisa passar os dados para a classe EmployeeContainer como parâmetro no construtor. Ele cria automaticamente seu modelo de dados.

 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)

A saída do console se parece com o seguinte:

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

SwiftJSONParse : Analise JSON como um fodão

Morto simples e fácil de ler!

Exemplo: obtenha o valor "mrap"de nicknamescomo uma String desta resposta JSON

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

Leva seus dados json NSDatacomo estão, sem necessidade de pré-processamento.

let parser = JSONParser(jsonData)

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

Disclaimer: Eu fiz isso e espero que ajude a todos. Sinta-se à vontade para melhorar!

Analisar JSON em Swift é um excelente trabalho para geração de código. Criei uma ferramenta em http://www.guideluxe.com/JsonToSwift para fazer exatamente isso.

Você fornece um objeto JSON de amostra com um nome de classe e a ferramenta irá gerar uma classe Swift correspondente, bem como quaisquer classes Swift subsidiárias necessárias, para representar a estrutura implícita pelo JSON de amostra. Também estão incluídos métodos de classe usados ​​para preencher objetos Swift, incluindo um que utiliza o método NSJSONSerialization.JSONObjectWithData. Os mapeamentos necessários dos objetos NSArray e NSDictionary são fornecidos.

A partir do código gerado, você só precisa fornecer um objeto NSData contendo JSON que corresponda à amostra fornecida para a ferramenta.

Além da Foundation, não há dependências.

Meu trabalho foi inspirado em http://json2csharp.com/ , que é muito útil para projetos .NET.

Veja como criar um objeto NSData a partir de um arquivo JSON.

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

1. Instale Swifty Json

Nota: se você está procurando por isso, também há uma grande chance de você não saber como instalar swifty. Siga as instruções aqui .

sudo gem install cocoapods

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

Em seguida, digite este comando:

pod init

Isso criará um padrão Podfilepara o seu projeto. O Podfileé onde você define as dependências seu projeto depende.

Digite este comando para abrir Podfileusando Xcodepara edição:

open -a Xcode Podfile

Adicione o Swiftyao podfile

platform :ios, '8.0'
use_frameworks!

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

2. Veja este exemplo

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

Todo o viewcontroller que mostra os dados na visão de coleta usando dois métodos de json parsig

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

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

Antes de você deve preparar o conjunto apropriado: Objetos mapeáveis ​​para analisar

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
}

dados - é o tipo de dados (estrutura) (ou seja, retornado por alguma resposta do servidor)

Este analisador usa genéricos para converter JSON em tipos Swift, o que reduz o código que você precisa digitar.

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

Abaixo está um exemplo do Swift Playground:

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

Crie um Projeto

Projete StoryBoard com um botão e um UITableview

Criar TableViewCell VC

Na ação do botão, insira os códigos a seguir

Lembre-se deste código para buscar matriz de dados em uma 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
    }
}

Isto é para buscar dados de dicionário

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

Exemplo de solicitação de API Swift 4

Fazer uso de JSONDecoder().decode

Veja este vídeo JSON analisando com Swift 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()

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