Comment puis-je personnaliser les touches avec Swift 4 Décodable protocole?

Manuellement, la personnalisation des clés de codage

Dans votre exemple, vous avez une auto-généré, de la conformité à Codable que tous vos biens soient aussi conformes à Codable. Cette conformité crée automatiquement un type de clé qui correspond tout simplement à la propriété des noms – qui est ensuite utilisé pour encoder pour/décodage à partir d'une clé unique conteneur.

Cependant un vraiment fonction propre de cette auto-généré à la conformité de l'est que si vous définissez une imbriqués enum dans votre type appelé "CodingKeys" (ou utiliser un typealias avec ce nom), qui est conforme à la CodingKey protocole Swift utilise automatiquement ce que le type de clé. Ceci permet donc de facilement personnaliser les clés de vos propriétés sont codés/décodés avec.

Ce que cela signifie est que vous pouvez simplement dire:

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

L'énumération des noms de cas besoin de faire correspondre les noms de propriété, et les valeurs brutes de ces cas besoin de faire correspondre les touches que vous êtes de l'encodage/décodage à partir de (sauf si spécifié autrement, les valeurs brutes d'un String énumération sera le même que le cas des noms). Par conséquent, la zip propriété sera désormais codés/décodés à l'aide de la clé "zip_code".

Les règles exactes pour l'auto-générés Encodable/Décodable la conformité sont détaillées par l'évolution de la proposition (l'emphase est mienne):

En plus automatique CodingKey exigence de synthèse pour
enums, Encodable & Decodable exigences peuvent être automatiquement
synthétisé pour certains types ainsi:

1. Types conformes à Encodable dont les propriétés sont toutes Encodable obtenir généré automatiquement Stringadossés à des CodingKey enum cartographie
   propriétés à des noms de cas. De même pour Decodable types dont
   les propriétés sont toutes Decodable

2. Types de tomber dans (1) — et de types de fournir manuellement une CodingKey enum (nommé CodingKeys, directement ou par l'intermédiaire d'un typealias) dont
   cas de la carte 1-de-1 à Encodable/Decodable propriétés par nom — get
   automatique de la synthèse de init(from:) et encode(to:) comme il convient,
   l'utilisation de ces propriétés et des touches de

3. Types qui tombent dans ni (1) ni (2) devra fournir une clé personnalisée de type si nécessaire et de fournir leurs propres init(from:) et
   encode(to:), selon le cas

Exemple de codage:

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

Exemple de décodage:

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

---

Automatique snake_case JSON clés pour camelCase noms de propriété

Dans Swift 4.1, si vous renommez votre zip propriété zipCode, vous pouvez prendre avantage de la clé de codage/décodage des stratégies sur JSONEncoder et JSONDecoder afin de convertir automatiquement les clés de codage entre camelCase et snake_case.

Exemple de codage:

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

Exemple de décodage:

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

Une chose importante à noter à propos de cette stratégie, cependant, est qu'il ne sera pas en mesure d'aller-retour de certains noms de propriété avec les acronymes ou sigles qui, selon la Swift API lignes directrices de conception, doit être uniformément cas supérieure ou inférieure (selon le poste).

Par exemple, une propriété nommée someURL sera codé avec la clé some_url, mais sur le décodage, ce sera transformée someUrl.

Pour résoudre ce problème, vous devez spécifier manuellement la clé de codage pour cette propriété à la chaîne que le décodeur s'attend, e.g someUrl dans ce cas (qui va encore être transformé à some_url par le codeur):

struct S : Codable {

  private enum CodingKeys : String, CodingKey {
    case someURL = "someUrl", someOtherProperty
  }

  var someURL: String
  var someOtherProperty: String
}

---

_{(Ce qui n'est pas strictement répondre à une question particulière, mais compte tenu de la canoniques de la nature de ce Q&A, je pense que c'est utile notamment)}

Personnalisé automatique JSON mappage de touches

Dans Swift 4.1, vous pouvez profiter de la coutume de la clé de codage/décodage des stratégies sur JSONEncoder et JSONDecoder, vous permettant de fournir une fonction personnalisée à la carte des clés de codage.

La fonction que vous fournissez prend un [CodingKey], qui représente le codage chemin d'accès pour le point en cours de codage/décodage (dans la plupart des cas, vous aurez seulement besoin de considérer le dernier élément, qui est, à la clé). La fonction retourne un CodingKey qui va remplacer la dernière touche à ce tableau.

Par exemple, UpperCamelCase JSON clés pour lowerCamelCase noms de propriété:

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

Vous pouvez coder avec le .convertToUpperCamelCase clés de la stratégie:

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

et décoder avec la .convertFromUpperCamelCase clés de la stratégie:

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

Ce que j'ai fait c'est de créer de structure propre, tout comme ce que vous obtenez à partir du JSON à l'égard de ses types de données.

Comme cela:

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
}

Après cela, vous devez créer une extension de la même struct l'extension de decodable et la enum de la même structure avec CodingKey et ensuite, vous devez initialiser le décodeur à l'aide de cette enum, avec ses clés et types de données (Clés viendra de l'enum et les types de données sera de venir ou de dire référencé à partir de la structure elle-même)

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

Vous avez besoin de changer ici chaque clé et les types de données en fonction de vos besoins et de l'utiliser avec le décodeur.