Related
This question already has answers here:
How do I use custom keys with Swift 4's Decodable protocol?
(4 answers)
Closed 1 year ago.
In my project I want to build a easy Crypto price app. So I want to get information from the Coinlore (https://www.coinlore.com/cryptocurrency-data-api) API. I made a request to the API and in the following I have to decode the JSON. But my problem is that the path to e.g. the price of the coin is "0.price_usd". But i can not create a struct named "0".
This is how the JSON looks:enter image description here
Can anyone please help me? Appreciate it!!!
Looking at their sample response
{
"data": [
{
"id": "90",
"symbol": "BTC",
"name": "Bitcoin",
"nameid": "bitcoin",
"rank": 1,
"price_usd": "6456.52",
"percent_change_24h": "-1.47",
"percent_change_1h": "0.05",
"percent_change_7d": "-1.07",
"price_btc": "1.00",
"market_cap_usd": "111586042785.56",
"volume24": 3997655362.9586277,
"volume24a": 3657294860.710187,
"csupply": "17282687.00",
"tsupply": "17282687",
"msupply": "21000000"
}],
"info": {
"coins_num": 1969,
"time": 1538560355
}
}
*note it has a closing ']' missing
you can create a swift model like so using
import Foundation
let json = "{\r\n \"data\": [\r\n {\r\n \"id\": \"90\",\r\n \"symbol\": \"BTC\",\r\n \"name\": \"Bitcoin\",\r\n \"nameid\": \"bitcoin\",\r\n \"rank\": 1,\r\n \"price_usd\": \"6456.52\",\r\n \"percent_change_24h\": \"-1.47\",\r\n \"percent_change_1h\": \"0.05\",\r\n \"percent_change_7d\": \"-1.07\",\r\n \"price_btc\": \"1.00\",\r\n \"market_cap_usd\": \"111586042785.56\",\r\n \"volume24\": 3997655362.9586277,\r\n \"volume24a\": 3657294860.710187,\r\n \"csupply\": \"17282687.00\",\r\n \"tsupply\": \"17282687\",\r\n \"msupply\": \"21000000\"\r\n }],\r\n \"info\": {\r\n \"coins_num\": 1969,\r\n \"time\": 1538560355\r\n }\r\n}"
struct Tokens: Codable {
let data: [SomeData]
}
struct SomeData: Codable {
let priceUsd: String
enum CodingKeys: String, CodingKey {
case priceUsd = "price_usd"
}
}
let tokens = try? JSONDecoder().decode(Tokens.self, from: json.data(using: .utf8)!)
print(tokens?.data.first?.priceUsd)
// edited my earlier answer, run the above it should get you your price
With Alamofire and Decodable protocol you can easily decode this:
func fetchExchangeData() {
let url = "https://api.coinlore.net/api/exchange/?id=5"
struct Root: Decodable {
let data: Datas
let pairs: [Pairs]
private enum CodingKeys : String, CodingKey {
case data = "0", pairs
}
}
struct Datas: Decodable {
let date: String
let name: String
let url: String
private enum CodingKeys : String, CodingKey {
case date = "date_live", name, url
}
}
struct Pairs: Decodable {
let base: String?
let price: Double?
let priceUsd: Double?
let quote: String?
let time: Double?
let volume: Double?
private enum CodingKeys : String, CodingKey {
case base, price, priceUsd = "price_usd", quote, time, volume
}
}
AF.request(url, method: .get).responseDecodable { (response: DataResponse<Root, AFError>) in
switch response.result {
case .success(let result):
for pair in result.pairs {
print(pair.priceUsd)
}
case .failure(let error):
print(error)
}
}
}
Just for the sample, we print out all the price_usd value. You can create a model for pairs, and save them into an array.
Swift 4 introduced support for native JSON encoding and decoding via the Decodable protocol. How do I use custom keys for this?
E.g., say I have a struct
struct Address:Codable {
var street:String
var zip:String
var city:String
var state:String
}
I can encode this to JSON.
let address = Address(street: "Apple Bay Street", zip: "94608", city: "Emeryville", state: "California")
if let encoded = try? encoder.encode(address) {
if let json = String(data: encoded, encoding: .utf8) {
// Print JSON String
print(json)
// JSON string is
{ "state":"California",
"street":"Apple Bay Street",
"zip":"94608",
"city":"Emeryville"
}
}
}
I can encode this back to an object.
let newAddress: Address = try decoder.decode(Address.self, from: encoded)
But If I had a json object that was
{
"state":"California",
"street":"Apple Bay Street",
"zip_code":"94608",
"city":"Emeryville"
}
How would I tell the decoder on Address that zip_code maps to zip? I believe you use the new CodingKey protocol, but I can't figure out how to use this.
Manually customising coding keys
In your example, you're getting an auto-generated conformance to Codable as all your properties also conform to Codable. This conformance automatically creates a key type that simply corresponds to the property names – which is then used in order to encode to/decode from a single keyed container.
However one really neat feature of this auto-generated conformance is that if you define a nested enum in your type called "CodingKeys" (or use a typealias with this name) that conforms to the CodingKey protocol – Swift will automatically use this as the key type. This therefore allows you to easily customise the keys that your properties are encoded/decoded with.
So what this means is you can just say:
struct Address : Codable {
var street: String
var zip: String
var city: String
var state: String
private enum CodingKeys : String, CodingKey {
case street, zip = "zip_code", city, state
}
}
The enum case names need to match the property names, and the raw values of these cases need to match the keys that you're encoding to/decoding from (unless specified otherwise, the raw values of a String enumeration will the same as the case names). Therefore, the zip property will now be encoded/decoded using the key "zip_code".
The exact rules for the auto-generated Encodable/Decodable conformance are detailed by the evolution proposal (emphasis mine):
In addition to automatic CodingKey requirement synthesis for
enums, Encodable & Decodable requirements can be automatically
synthesized for certain types as well:
Types conforming to Encodable whose properties are all Encodable get an automatically generated String-backed CodingKey enum mapping
properties to case names. Similarly for Decodable types whose
properties are all Decodable
Types falling into (1) — and types which manually provide a CodingKey enum (named CodingKeys, directly, or via a typealias) whose
cases map 1-to-1 to Encodable/Decodable properties by name — get
automatic synthesis of init(from:) and encode(to:) as appropriate,
using those properties and keys
Types which fall into neither (1) nor (2) will have to provide a custom key type if needed and provide their own init(from:) and
encode(to:), as appropriate
Example encoding:
import Foundation
let address = Address(street: "Apple Bay Street", zip: "94608",
city: "Emeryville", state: "California")
do {
let encoded = try JSONEncoder().encode(address)
print(String(decoding: encoded, as: UTF8.self))
} catch {
print(error)
}
//{"state":"California","street":"Apple Bay Street","zip_code":"94608","city":"Emeryville"}
Example decoding:
// using the """ multi-line string literal here, as introduced in SE-0168,
// to avoid escaping the quotation marks
let jsonString = """
{"state":"California","street":"Apple Bay Street","zip_code":"94608","city":"Emeryville"}
"""
do {
let decoded = try JSONDecoder().decode(Address.self, from: Data(jsonString.utf8))
print(decoded)
} catch {
print(error)
}
// Address(street: "Apple Bay Street", zip: "94608",
// city: "Emeryville", state: "California")
Automatic snake_case JSON keys for camelCase property names
In Swift 4.1, if you rename your zip property to zipCode, you can take advantage of the key encoding/decoding strategies on JSONEncoder and JSONDecoder in order to automatically convert coding keys between camelCase and snake_case.
Example encoding:
import Foundation
struct Address : Codable {
var street: String
var zipCode: String
var city: String
var state: String
}
let address = Address(street: "Apple Bay Street", zipCode: "94608",
city: "Emeryville", state: "California")
do {
let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase
let encoded = try encoder.encode(address)
print(String(decoding: encoded, as: UTF8.self))
} catch {
print(error)
}
//{"state":"California","street":"Apple Bay Street","zip_code":"94608","city":"Emeryville"}
Example decoding:
let jsonString = """
{"state":"California","street":"Apple Bay Street","zip_code":"94608","city":"Emeryville"}
"""
do {
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let decoded = try decoder.decode(Address.self, from: Data(jsonString.utf8))
print(decoded)
} catch {
print(error)
}
// Address(street: "Apple Bay Street", zipCode: "94608",
// city: "Emeryville", state: "California")
One important thing to note about this strategy however is that it won't be able to round-trip some property names with acronyms or initialisms which, according to the Swift API design guidelines, should be uniformly upper or lower case (depending on the position).
For example, a property named someURL will be encoded with the key some_url, but on decoding, this will be transformed to someUrl.
To fix this, you'll have to manually specify the coding key for that property to be string that the decoder expects, e.g someUrl in this case (which will still be transformed to some_url by the encoder):
struct S : Codable {
private enum CodingKeys : String, CodingKey {
case someURL = "someUrl", someOtherProperty
}
var someURL: String
var someOtherProperty: String
}
(This doesn't strictly answer your specific question, but given the canonical nature of this Q&A, I feel it's worth including)
Custom automatic JSON key mapping
In Swift 4.1, you can take advantage of the custom key encoding/decoding strategies on JSONEncoder and JSONDecoder, allowing you to provide a custom function to map coding keys.
The function you provide takes a [CodingKey], which represents the coding path for the current point in encoding/decoding (in most cases, you'll only need to consider the last element; that is, the current key). The function returns a CodingKey that will replace the last key in this array.
For example, UpperCamelCase JSON keys for lowerCamelCase property names:
import Foundation
// wrapper to allow us to substitute our mapped string keys.
struct AnyCodingKey : CodingKey {
var stringValue: String
var intValue: Int?
init(_ base: CodingKey) {
self.init(stringValue: base.stringValue, intValue: base.intValue)
}
init(stringValue: String) {
self.stringValue = stringValue
}
init(intValue: Int) {
self.stringValue = "\(intValue)"
self.intValue = intValue
}
init(stringValue: String, intValue: Int?) {
self.stringValue = stringValue
self.intValue = intValue
}
}
extension JSONEncoder.KeyEncodingStrategy {
static var convertToUpperCamelCase: JSONEncoder.KeyEncodingStrategy {
return .custom { codingKeys in
var key = AnyCodingKey(codingKeys.last!)
// uppercase first letter
if let firstChar = key.stringValue.first {
let i = key.stringValue.startIndex
key.stringValue.replaceSubrange(
i ... i, with: String(firstChar).uppercased()
)
}
return key
}
}
}
extension JSONDecoder.KeyDecodingStrategy {
static var convertFromUpperCamelCase: JSONDecoder.KeyDecodingStrategy {
return .custom { codingKeys in
var key = AnyCodingKey(codingKeys.last!)
// lowercase first letter
if let firstChar = key.stringValue.first {
let i = key.stringValue.startIndex
key.stringValue.replaceSubrange(
i ... i, with: String(firstChar).lowercased()
)
}
return key
}
}
}
You can now encode with the .convertToUpperCamelCase key strategy:
let address = Address(street: "Apple Bay Street", zipCode: "94608",
city: "Emeryville", state: "California")
do {
let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToUpperCamelCase
let encoded = try encoder.encode(address)
print(String(decoding: encoded, as: UTF8.self))
} catch {
print(error)
}
//{"Street":"Apple Bay Street","City":"Emeryville","State":"California","ZipCode":"94608"}
and decode with the .convertFromUpperCamelCase key strategy:
let jsonString = """
{"Street":"Apple Bay Street","City":"Emeryville","State":"California","ZipCode":"94608"}
"""
do {
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromUpperCamelCase
let decoded = try decoder.decode(Address.self, from: Data(jsonString.utf8))
print(decoded)
} catch {
print(error)
}
// Address(street: "Apple Bay Street", zipCode: "94608",
// city: "Emeryville", state: "California")
With Swift 4.2, according to your needs, you may use one of the 3 following strategies in order to make your model objects custom property names match your JSON keys.
#1. Using custom coding keys
When you declare a struct that conforms to Codable (Decodable and Encodable protocols) with the following implementation...
struct Address: Codable {
var street: String
var zip: String
var city: String
var state: String
}
... the compiler automatically generates a nested enum that conforms to CodingKey protocol for you.
struct Address: Codable {
var street: String
var zip: String
var city: String
var state: String
// compiler generated
private enum CodingKeys: String, CodingKey {
case street
case zip
case city
case state
}
}
Therefore, if the keys used in your serialized data format don't match the property names from your data type, you can manually implement this enum and set the appropriate rawValue for the required cases.
The following example shows how to do:
import Foundation
struct Address: Codable {
var street: String
var zip: String
var city: String
var state: String
private enum CodingKeys: String, CodingKey {
case street
case zip = "zip_code"
case city
case state
}
}
Encode (replacing zip property with "zip_code" JSON key):
let address = Address(street: "Apple Bay Street", zip: "94608", city: "Emeryville", state: "California")
let encoder = JSONEncoder()
if let jsonData = try? encoder.encode(address), let jsonString = String(data: jsonData, encoding: .utf8) {
print(jsonString)
}
/*
prints:
{"state":"California","street":"Apple Bay Street","zip_code":"94608","city":"Emeryville"}
*/
Decode (replacing "zip_code" JSON key with zip property):
let jsonString = """
{"state":"California","street":"Apple Bay Street","zip_code":"94608","city":"Emeryville"}
"""
let decoder = JSONDecoder()
if let jsonData = jsonString.data(using: .utf8), let address = try? decoder.decode(Address.self, from: jsonData) {
print(address)
}
/*
prints:
Address(street: "Apple Bay Street", zip: "94608", city: "Emeryville", state: "California")
*/
#2. Using snake case to camel case key coding strategies
If your JSON has snake-cased keys and you want to convert them to camel-cased properties for your model object, you can set your JSONEncoder's keyEncodingStrategy and JSONDecoder's keyDecodingStrategy properties to .convertToSnakeCase.
The following example shows how to do:
import Foundation
struct Address: Codable {
var street: String
var zipCode: String
var cityName: String
var state: String
}
Encode (converting camel cased properties into snake cased JSON keys):
let address = Address(street: "Apple Bay Street", zipCode: "94608", cityName: "Emeryville", state: "California")
let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase
if let jsonData = try? encoder.encode(address), let jsonString = String(data: jsonData, encoding: .utf8) {
print(jsonString)
}
/*
prints:
{"state":"California","street":"Apple Bay Street","zip_code":"94608","city_name":"Emeryville"}
*/
Decode (converting snake cased JSON keys into camel cased properties):
let jsonString = """
{"state":"California","street":"Apple Bay Street","zip_code":"94608","city_name":"Emeryville"}
"""
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
if let jsonData = jsonString.data(using: .utf8), let address = try? decoder.decode(Address.self, from: jsonData) {
print(address)
}
/*
prints:
Address(street: "Apple Bay Street", zipCode: "94608", cityName: "Emeryville", state: "California")
*/
#3. Using custom key coding strategies
If necessary, JSONEncoder and JSONDecoder allow you to set a custom strategy to map coding keys using JSONEncoder.KeyEncodingStrategy.custom(_:) and JSONDecoder.KeyDecodingStrategy.custom(_:).
The following example shows how to implement them:
import Foundation
struct Address: Codable {
var street: String
var zip: String
var city: String
var state: String
}
struct AnyKey: CodingKey {
var stringValue: String
var intValue: Int?
init?(stringValue: String) {
self.stringValue = stringValue
}
init?(intValue: Int) {
self.stringValue = String(intValue)
self.intValue = intValue
}
}
Encode (converting lowercased first letter properties into uppercased first letter JSON keys):
let address = Address(street: "Apple Bay Street", zip: "94608", city: "Emeryville", state: "California")
let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .custom({ (keys) -> CodingKey in
let lastKey = keys.last!
guard lastKey.intValue == nil else { return lastKey }
let stringValue = lastKey.stringValue.prefix(1).uppercased() + lastKey.stringValue.dropFirst()
return AnyKey(stringValue: stringValue)!
})
if let jsonData = try? encoder.encode(address), let jsonString = String(data: jsonData, encoding: .utf8) {
print(jsonString)
}
/*
prints:
{"Zip":"94608","Street":"Apple Bay Street","City":"Emeryville","State":"California"}
*/
Decode (converting uppercased first letter JSON keys into lowercased first letter properties):
let jsonString = """
{"State":"California","Street":"Apple Bay Street","Zip":"94608","City":"Emeryville"}
"""
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .custom({ (keys) -> CodingKey in
let lastKey = keys.last!
guard lastKey.intValue == nil else { return lastKey }
let stringValue = lastKey.stringValue.prefix(1).lowercased() + lastKey.stringValue.dropFirst()
return AnyKey(stringValue: stringValue)!
})
if let jsonData = jsonString.data(using: .utf8), let address = try? decoder.decode(Address.self, from: jsonData) {
print(address)
}
/*
prints:
Address(street: "Apple Bay Street", zip: "94608", city: "Emeryville", state: "California")
*/
Sources:
Apple developer documentation: "Encoding and Decoding Custom Types"
WWDC 2017 session 212: "What's new in Foundation"
MartianCraft: "Implementing a custom key strategy for coding types"
What I have done is create own structure just like what you are getting from the JSON with respect to its data types.
Just like this:
struct Track {
let id : Int
let contributingArtistNames:String
let name : String
let albumName :String
let copyrightP:String
let copyrightC:String
let playlistCount:Int
let trackPopularity:Int
let playlistFollowerCount:Int
let artistFollowerCount : Int
let label : String
}
After this you need to create an extension of the same struct extending decodable and the enum of the same structure with CodingKey and then you need to initialize the decoder using this enum with its keys and datatypes (Keys will come from the enum and the datatypes will be coming or say referenced from the structure itself)
extension Track: Decodable {
enum TrackCodingKeys: String, CodingKey {
case id = "id"
case contributingArtistNames = "primaryArtistsNames"
case spotifyId = "spotifyId"
case name = "name"
case albumName = "albumName"
case albumImageUrl = "albumImageUrl"
case copyrightP = "copyrightP"
case copyrightC = "copyrightC"
case playlistCount = "playlistCount"
case trackPopularity = "trackPopularity"
case playlistFollowerCount = "playlistFollowerCount"
case artistFollowerCount = "artistFollowers"
case label = "label"
}
init(from decoder: Decoder) throws {
let trackContainer = try decoder.container(keyedBy: TrackCodingKeys.self)
if trackContainer.contains(.id){
id = try trackContainer.decode(Int.self, forKey: .id)
}else{
id = 0
}
if trackContainer.contains(.contributingArtistNames){
contributingArtistNames = try trackContainer.decode(String.self, forKey: .contributingArtistNames)
}else{
contributingArtistNames = ""
}
if trackContainer.contains(.spotifyId){
spotifyId = try trackContainer.decode(String.self, forKey: .spotifyId)
}else{
spotifyId = ""
}
if trackContainer.contains(.name){
name = try trackContainer.decode(String.self, forKey: .name)
}else{
name = ""
}
if trackContainer.contains(.albumName){
albumName = try trackContainer.decode(String.self, forKey: .albumName)
}else{
albumName = ""
}
if trackContainer.contains(.albumImageUrl){
albumImageUrl = try trackContainer.decode(String.self, forKey: .albumImageUrl)
}else{
albumImageUrl = ""
}
if trackContainer.contains(.copyrightP){
copyrightP = try trackContainer.decode(String.self, forKey: .copyrightP)
}else{
copyrightP = ""
}
if trackContainer.contains(.copyrightC){
copyrightC = try trackContainer.decode(String.self, forKey: .copyrightC)
}else{
copyrightC = ""
}
if trackContainer.contains(.playlistCount){
playlistCount = try trackContainer.decode(Int.self, forKey: .playlistCount)
}else{
playlistCount = 0
}
if trackContainer.contains(.trackPopularity){
trackPopularity = try trackContainer.decode(Int.self, forKey: .trackPopularity)
}else{
trackPopularity = 0
}
if trackContainer.contains(.playlistFollowerCount){
playlistFollowerCount = try trackContainer.decode(Int.self, forKey: .playlistFollowerCount)
}else{
playlistFollowerCount = 0
}
if trackContainer.contains(.artistFollowerCount){
artistFollowerCount = try trackContainer.decode(Int.self, forKey: .artistFollowerCount)
}else{
artistFollowerCount = 0
}
if trackContainer.contains(.label){
label = try trackContainer.decode(String.self, forKey: .label)
}else{
label = ""
}
}
}
You need to change here each and every key and datatypes according to your needs and use it with the decoder.
By using CodingKey you can use custom keys in codable or decodable protocol.
struct person: Codable {
var name: String
var age: Int
var street: String
var state: String
private enum CodingKeys: String, CodingKey {
case name
case age
case street = "Street_name"
case state
} }
I am trying to parse the json. But the problem is I have json inside to it another json String. Like :
{
"count": 284,
"next": "http://X:X:X:X:8080/api/sensor/last5feed?page=2&search=XXXXX",
"previous": null,
"results": [
{
"id": 571,
"feed": "{'app_id': 'XXXXX', 'dev_id': 'XXXX', 'hardware_serial': 'XXXXX', 'port': 6, 'counter': 4290, 'payload_raw': 'AQEBIwXsF4IAAAA=', 'payload_fields': {'aamsg_type': 'weather', 'abstatus': 0, 'batteryV': 3.5, 'battery_low': 'no', 'humiP': 60.2, 'tempC': 15.2}, 'metadata': {'time': '2020-01-23T15:09:32.350967362Z', 'frequency': 868.1, 'modulation': 'LORA', 'data_rate': 'SF7BW125', 'airtime': 61696000, 'coding_rate': '4/5', 'gateways': [{'gtw_id': 'XXXXX', 'timestamp': 3227230963, 'time': '2020-01-23T15:09:32.326146Z', 'channel': 0, 'rssi': -98, 'snr': 4.8, 'rf_chain': 1, 'latitude': 57.124737, 'longitude': -2.1646452, 'altitude': 90, 'location_source': 'registry'}]}}",
"created_at": "2020-01-23T15:09:32.630326Z",
"sensor": 1
},
{
"id": 569,
"feed": "{'app_id': 'XXXXXX', 'dev_id': 'XXXX', 'hardware_serial': 'XXXX', 'port': 6, 'counter': 4289, 'payload_raw': 'XXXXX', 'payload_fields': {'aamsg_type': 'weather', 'abstatus': 0, 'batteryV': 3.5, 'battery_low': 'no', 'humiP': 57.6, 'tempC': 16.9}, 'metadata': {'time': '2020-01-23T14:09:32.132070865Z', 'frequency': 867.3, 'modulation': 'LORA', 'data_rate': 'SF7BW125', 'airtime': 61696000, 'coding_rate': '4/5', 'gateways': [{'gtw_id': 'XXXXXX', 'timestamp': 3921981659, 'time': '2020-01-23T14:09:32.104672Z', 'channel': 4, 'rssi': -107, 'snr': 8.2, 'rf_chain': 0, 'latitude': 57.124737, 'longitude': -2.1646452, 'altitude': 90, 'location_source': 'registry'}]}}",
"created_at": "2020-01-23T14:09:32.448929Z",
"sensor": 1
}
}
I am getting the values till feed. But I am not able to parse further, My code is :
if(status_code == 200){
if let json = response.data {
do{
let data = try JSON(data: json)
let result = data["results"].arrayObject! as NSArray
let ct = result.count
if(ct != 0 ) {
self.noDataFound.isHidden = true
for i in 0...ct-1 {
let data = result[i] as? NSDictionary
let feed = data?.value(forKey: "feed") as? NSString
let data3 = try JSON(data: feed as! Data) .
print(data3)
}
}
} catch {} }}
I need to get the hardware_serial from feed. Can any body please help me what i am doing wrong here!! Thanks!!!
The string for key feed is not valid JSON. You have to replace the single quotes with double quotes.
Create a Data object from the string (casting the type doesn't work).
Create a JSON object from the data.
Get the values you need.
Side note:
Don't use NS... collection types and NSString in Swift.
Use Codable to parse the above JSON response.
Models:
struct Root: Codable {
let count: Int
let next: String
let previous: String?
let results: [Result]
}
struct Result: Codable {
let id: Int
let feed, createdAt: String
let sensor: Int
}
Parse the JSON data like so,
do {
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let response = try decoder.decode(Root.self, from: data)
print(response)
} catch {
print(error)
}
First, peel off the piece you want:
struct ResultWrapper: Decodable {
let results: [Result]
}
And then build a custom decoder to extract feed, which is malformed. Single-quotes are not legal JSON. As a hack, the following code just substitutes all single-quotes with double-quotes, but this won't work if there are any embedded quoted-single-quotes.
struct Result: Decodable {
enum CodingKeys: String, CodingKey { case feed }
let feed: Feed
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
// inner JSON is mal-formed. Have to fix it.
let feedString = try container.decode(String.self, forKey: .feed)
.replacingOccurrences(of: "'", with: "\"")
feed = try JSONDecoder().decode(Feed.self, from: Data(feedString.utf8))
}
}
Finally, decoding Feed is mechanical, but requires custom CodingKeys. I recommend quicktype for that:
// https://app.quicktype.io?share=7O6iNJ3ugXb4mr84TIoG
struct Feed: Codable {
var appID, devID, hardwareSerial: String
var port, counter: Int
var payloadRaw: String
var payloadFields: PayloadFields
var metadata: Metadata
enum CodingKeys: String, CodingKey {
case appID = "app_id"
case devID = "dev_id"
case hardwareSerial = "hardware_serial"
case port, counter
case payloadRaw = "payload_raw"
case payloadFields = "payload_fields"
case metadata
}
}
// MARK: - Metadata
struct Metadata: Codable {
var time: String
var frequency: Double
var modulation, dataRate: String
var airtime: Int
var codingRate: String
var gateways: [Gateway]
enum CodingKeys: String, CodingKey {
case time, frequency, modulation
case dataRate = "data_rate"
case airtime
case codingRate = "coding_rate"
case gateways
}
}
// MARK: - Gateway
struct Gateway: Codable {
var gtwID: String
var timestamp: Int
var time: String
var channel, rssi: Int
var snr: Double
var rfChain: Int
var latitude, longitude: Double
var altitude: Int
var locationSource: String
enum CodingKeys: String, CodingKey {
case gtwID = "gtw_id"
case timestamp, time, channel, rssi, snr
case rfChain = "rf_chain"
case latitude, longitude, altitude
case locationSource = "location_source"
}
}
// MARK: - PayloadFields
struct PayloadFields: Codable {
var aamsgType: String
var abstatus: Int
var batteryV: Double
var batteryLow: String
var humiP, tempC: Double
enum CodingKeys: String, CodingKey {
case aamsgType = "aamsg_type"
case abstatus, batteryV
case batteryLow = "battery_low"
case humiP, tempC
}
}
I am using Codable to parse my JSON response object.
Is it a good idea to include enum CodingKeys: String, CodingKey so in the future if the JSON response object has extra properties added to it, they will be ignored and not cause a crash?
It's just a lot of extra code to backfill when you have 30 different models in the app.
Not sure if there is a way better way to handle this?
Below is an example that runs fine and proves that extra json keys that are not defined in the struct will be ignored
let data = """
{ "id": 32, "name" : "abc", "other": "gbdfb"}
""".data(using: .utf8)!
struct JSONData: Decodable {
let id: Int
let name: String
}
do {
let result = try JSONDecoder().decode(JSONData.self, from: data)
print(result)
} catch {
print(error)
}
The answer is No.The Codable only decodes the values that are found in the json. Moreover, it isn't necessary if you add enum CodingKeys: String, CodingKey to every Codable Protocol. You may leave this with null value.
We use to write enum CodingKeys: String, CodingKey if the key isn't snakeCased. But Codable has it's own keyDecodingStrategy
let jsonString = """
[
{
"profile_name": "Ankur Lahiry",
},
{
"profile_name": "Karim Rahman",
}
]
"""
let jsonData = Data(jsonString.utf8)
struct Name : Codable {
var profileName: String?
}
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase // will solve enum CodingKeys: String, CodingKey issue
do {
let names = try decoder.decode([Name].self, from: jsonData)
print(names)
} catch {
print("error")
}
I'm calling the API endpoint and the JSON response looks like this:
{
"id": 299536,
"cast": [
{
"cast_id": 1,
"character": "Tony Stark / Iron Man",
"credit_id": "54a9cfa29251414d5b00553d",
"gender": 2,
"id": 3223,
"name": "Robert Downey Jr.",
"order": 0,
"profile_path": "/1YjdSym1jTG7xjHSI0yGGWEsw5i.jpg"
},
{
"cast_id": 6,
"character": "Thor Odinson",
"credit_id": "54a9d012c3a3680c29005762",
"gender": 2,
"id": 74568,
"name": "Chris Hemsworth",
"order": 1,
"profile_path": "/lrhth7yK9p3vy6p7AabDUM1THKl.jpg"
},
{
"cast_id": 13,
"character": "Bruce Banner / Hulk",
"credit_id": "573fc00592514177ec00010a",
"gender": 2,
"id": 103,
"name": "Mark Ruffalo",
"order": 2,
"profile_path": "/isQ747u0MU8U9gdsNlPngjABclH.jpg"
}
]
This is the struct that I've made for the codable protocol.
struct MovieCast: Codable {
let id: Int
let cast: [Cast]
let crew: [Crew]
}
struct Cast: Codable {
let castID: Int
let character, creditID: String
let gender, id: Int
let name: String
let order: Int
let profilePath: String?
enum CodingKeys: String, CodingKey {
case castID = "cast_id"
case character
case creditID = "credit_id"
case gender, id, name, order
case profilePath = "profile_path"
}
}
struct Crew: Codable {
let creditID: String
let department: Department
let gender, id: Int
let job, name: String
let profilePath: String?
enum CodingKeys: String, CodingKey {
case creditID = "credit_id"
case department, gender, id, job, name
case profilePath = "profile_path"
}
}
enum Department: String, Codable {
case art = "Art"
case camera = "Camera"
case costumeMakeUp = "Costume & Make-Up"
case crew = "Crew"
case directing = "Directing"
case editing = "Editing"
case lighting = "Lighting"
case production = "Production"
case sound = "Sound"
case visualEffects = "Visual Effects"
case writing = "Writing"
}
My question is, how can I loop through the objects in a single array using Swift 4? I am using Decodable protocol and have struct that looks like this: (note that I let out some of the json response properties above so the snippet wouldn't be too long)
My goal is to get the
profile_path
out of every object and append it to the array of Strings.
After you get the response try this code in viewDidLoad()
if let dict = response.result.value as? [string:Anyobject]() //fetching the response
if let innerdict = dict["cast"] as? [[string:Anyobject]]()
for cast in innerdict {
if let profile_path = cast[ "profile_path"] as? String
print("profile_path") // to check the profilepath
}
// this is it to get the profile path then append it in the array of type string
Your MovieCast struct contains 2 arrays, one of Cast objects and one of Crew objects.
You could create a protocol Staff that has the shared properties from both (gender, name, profilePath), declare that both types conform to that protocol, and then combine your arrays of Cast and Crew objects into an array of Staff.
Then you could map the resulting array to an array of strings from the profilePath values of each entry in the array:
protocol Staff {
var gender: Int { get }
var name: String { get }
var profilePath: String? { get }
}
Change Cast and Crew like this:
struct Cast: Codable & Staff
struct Crew: Codable & Staff
if you have a crew:
var movieCrew: MovieCast
//Code to load a moview crew
Then
let castAndCrew = (movieCrew.cast as [Staff]) + ((movieCrew.crew as [Staff]?) ?? [])
let allProfilePaths = castAndCrew.compactMap { $0.profilePath }
(Note that I typed this into the SO editor, and my syntax is rarely perfect "out of the gate." It will likely need some minor cleanup.)