Sort "allKeys" with mapping - json

Question

I decode a JSON with dynamic string keys which looks like this:
{
"dynamickey1":
{"infos1": "blabla","infos2": 21},
"dynamickey2":
{"infos1": "blabla","infos2": 12},
... }
They are sorted as I wanted, as I put a list of string in the URL. But when it decodes the dictionary with the code below (EDIT : i put the complete code), I lost the order:
struct Devise {
let nom : String
let EUR: Float
let ETH: Float
}
struct DataPrix {
let devises: [Devise]
struct DataPrixCodingKeys: CodingKey {
let stringValue : String
init?(stringValue: String) {
self.stringValue = stringValue
}
var intValue : Int? {return nil}
init?(intValue: Int) {return nil}
}
enum DeviseCodingKeys: String, CodingKey {
case ETH
case EUR
}
}
let decoder = JSONDecoder()
extension DataPrix: Decodable {
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy : DataPrixCodingKeys.self)
self.devises = try (container.allKeys).map { key in
let devisesContainer = try container.nestedContainer(keyedBy: DeviseCodingKeys.self, forKey: key)
let deviseName = key.stringValue
let EUR = try devisesContainer.decode(Float.self, forKey: .EUR)
let ETH = try devisesContainer.decode(Float.self, forKey: .ETH)
return Devise(nom: deviseName, EUR: EUR, ETH: ETH)
}
}
}
So is it possible to sort them alphabetically at this point or at least keep the same order I had in my initial list?

Answer 1

This is more likely a problem with the type of container. It seems you are using NSDictionary, which has allKeys of type Any. Any is not Comparable.
The simplest solution is to cast the dictionary to [String: Any]. Then you can use directly container.keys.sorted(), where < is the default comparator.
let jsonString = """
{
"dynamickey1": {"infos1": "blabla","infos2": 21},
"dynamickey2": {"infos1": "blabla","infos2": 12}
}
"""
let jsonData = jsonString.data(using: .utf8)!
if let container = (try? JSONSerialization.jsonObject(with: jsonData, options: [])) as? [String: Any] {
let sortedKeys = container.keys.sorted()
print(sortedKeys)
}
Or, switch to using Codable protocol and decode the JSON type-safely:
let jsonString = """
{
"dynamickey1": {"infos1": "blabla","infos2": 21},
"dynamickey2": {"infos1": "blabla","infos2": 12}
}
"""
let jsonData = jsonString.data(using: .utf8)!
struct Info: Codable {
let infos1: String
let infos2: Int
}
let parsed = try? JSONDecoder().decode([String: Info].self, from: jsonData)
if let container = parsed {
print(container.keys.sorted())
}
EDIT Solution for the updated question:
let jsonString = """
{"XPR": {"EUR":0.6866,"ETH":0.001088}}
"""
let jsonData = jsonString.data(using: .utf8)!
enum Currency: String, CodingKey, Comparable {
case XPR
case EUR
case ETH
public static func < (lhs: Currency, rhs: Currency) -> Bool {
return lhs.rawValue < rhs.rawValue
}
}
struct Devise: Decodable {
let name: String
let rates: [Currency: Double]
public init(from decoder: Decoder) throws {
name = decoder.codingPath.last?.stringValue ?? ""
let container = try decoder.container(keyedBy: Currency.self)
var rates: [Currency: Double] = [:]
try container.allKeys.forEach {
rates[$0] = try container.decode(Double.self, forKey: $0)
}
self.rates = rates
}
}
struct DataPrix: Decodable {
let devises: [Devise]
public init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: Currency.self)
devises = try container.allKeys.sorted().map {
return try container.decode(Devise.self, forKey: $0)
}
}
}
let decoder = JSONDecoder()
do {
let exchangeRates = try decoder.decode(DataPrix.self, from: jsonData)
print(exchangeRates)
} catch {
print(error)
}
However, if your keys are truly dynamic, you cannot avoid a dictionary and the best would be just to use it:
let decoder = JSONDecoder()
do {
let exchangeRates = try decoder.decode([String: [String: Double]].self, from: jsonData)
print(exchangeRates)
} catch {
print(error)
}

Answer 2

You can sort like this:
let dictionary = ["key1":"test","key0":"","key5":""]
dictionary.keys.sorted { $0.localizedCaseInsensitiveCompare($1) == ComparisonResult.orderedAscending }.map { key in
// code
}
so for your Code you can use Like this
let keys = dic.keys.sorted { $0.localizedCaseInsensitiveCompare($1) == ComparisonResult.orderedAscending }
print( keys.map { (key) -> [String : Devise]? in
guard let value = dic[key] else {return nil}
return [key : value]
}.compactMap({$0}))