Как использовать настраиваемые ключи с протоколом Decodable Swift 4?

102

Swift 4 представил поддержку собственного кодирования и декодирования JSON через Decodableпротокол. Как мне использовать для этого специальные ключи?

Например, скажем, у меня есть структура

struct Address:Codable {
    var street:String
    var zip:String
    var city:String
    var state:String
}

Я могу закодировать это в 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" 
           }
    }
}

Я могу закодировать это обратно в объект.

    let newAddress: Address = try decoder.decode(Address.self, from: encoded)

Но если бы у меня был объект json, который был 

{ 
   "state":"California", 
   "street":"Apple Bay Street", 
   "zip_code":"94608", 
   "city":"Emeryville" 
}

Как я могу указать декодеру на Addressэтих zip_codeкартах zip? Я считаю, что вы используете новый CodingKeyпротокол, но я не могу понять, как его использовать.

json swift swift4 codable Крисмандерсон
источник

Ответы:

258

Настройка ключей кодирования вручную

В вашем примере вы получаете автоматически сгенерированное соответствие, Codableкоторому также соответствуют все ваши свойства Codable. Это соответствие автоматически создает тип ключа, который просто соответствует именам свойств, который затем используется для кодирования / декодирования из контейнера с одним ключом.

Однако одна действительно интересная особенность этого автоматически сгенерированного соответствия заключается в том, что если вы определяете вложенный enumв свой тип с именем " CodingKeys" (или используете typealiasс этим именем), который соответствует CodingKeyпротоколу, Swift автоматически будет использовать его в качестве типа ключа. Таким образом, это позволяет вам легко настраивать ключи, с помощью которых ваши свойства кодируются / декодируются.

Это означает, что вы можете просто сказать:

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

Имена кейсов перечисления должны соответствовать именам свойств, а необработанные значения этих кейсов должны соответствовать ключам, которые вы кодируете / декодируете (если не указано иное, необработанные значения Stringперечисления будут такими же, как имена кейсов. ). Следовательно, zipсвойство теперь будет кодироваться / декодироваться с помощью ключа "zip_code".

Точные правила для автогенерации Encodable/ Decodableсоответствия детализированы в предложении эволюции (выделено мной):

В дополнение к автоматическому CodingKeyсинтезу Требование enums, Encodableи Decodableтребования могут быть автоматически синтезированы для определенных типов , а также:

  1. Типы , соответствующие Encodableсвойства которого все Encodableполучает автоматически генерируемый String-backed CodingKeyперечислений свойства отображения имен в случае. Аналогично для Decodableтипов, все свойства которыхDecodable

  2. Типы попадающих в (1) - и типах , которые вручную обеспечивают CodingKey enum( по имени CodingKeys, непосредственно, или через typealias) , чьи дела на карту 1-к-1 к Encodable/ Decodableсвойств по названию - получить автоматический синтез init(from:)и по encode(to:)мере необходимости, используя эти свойства и ключи

  3. Типы, которые не попадают ни в (1), ни в (2), должны будут предоставлять настраиваемый тип ключа, если необходимо, и предоставлять свои собственные init(from:)и encode(to:), при необходимости,

Пример кодировки:

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

Пример расшифровки:

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

Автоматические snake_caseключи JSON для camelCaseимен свойств

В Swift 4.1, если вы переименуете свое zipсвойство в zipCode, вы можете воспользоваться преимуществами ключевых стратегий кодирования / декодирования JSONEncoderи JSONDecoderдля автоматического преобразования ключей кодирования между camelCaseи snake_case.

Пример кодировки:

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

Пример расшифровки:

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

Тем не менее, одна важная вещь, которую следует отметить в этой стратегии, заключается в том, что она не сможет передавать некоторые имена свойств с помощью акронимов или инициализмов, которые, согласно руководящим принципам проектирования Swift API , должны быть одинаково прописными или строчными (в зависимости от положения ).

Например, свойство с именем someURLбудет закодировано с помощью ключа some_url, но при декодировании оно будет преобразовано в someUrl.

Чтобы исправить это, вам нужно вручную указать ключ кодирования для этого свойства, который должен быть строкой, которую ожидает декодер, например, someUrlв этом случае (которая все равно будет преобразована some_urlкодировщиком):

struct S : Codable {

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

  var someURL: String
  var someOtherProperty: String
}

(Это не совсем ответ на ваш конкретный вопрос, но, учитывая канонический характер этого вопроса и ответа, я считаю, что его стоит включить)

Пользовательское автоматическое сопоставление ключей JSON

В Swift 4.1 вы можете воспользоваться преимуществами настраиваемых стратегий кодирования / декодирования ключей на JSONEncoderи JSONDecoder, что позволяет вам предоставить настраиваемую функцию для сопоставления ключей кодирования.

Предоставляемая вами функция принимает значение [CodingKey], которое представляет путь кодирования для текущей точки кодирования / декодирования (в большинстве случаев вам нужно будет учитывать только последний элемент, то есть текущий ключ). Функция возвращает CodingKey, который заменит последний ключ в этом массиве.

Например, UpperCamelCaseключи JSON для lowerCamelCaseимен свойств:

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

Теперь вы можете кодировать с помощью .convertToUpperCamelCaseключевой стратегии:

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

и декодируем с помощью .convertFromUpperCamelCaseключевой стратегии:

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")
Хэмиш
источник
Просто наткнулся на это сам! Интересно, есть ли способ переопределить только один ключ, который я хочу изменить, и оставить остальные в покое? Например, в заявлении case под CodingKeysenum; могу я просто перечислить один ключ, который я меняю?
Крисмандерсон 06
2
"""для многострочного литерала :)
Martin R
6
@MartinR Или даже просто однострочный литерал без необходимости экранировать "s: D
Хэмиш
1
@chrismanderson Точно - особенно с учетом того, что компилятор требует, чтобы имена наблюдений синхронизировались с именами свойств (это даст вам сообщение об ошибке, говорящее, что вы не соответствуете Codableдругому)
Хэмиш
1
@ClayEllis Ах, да, хотя, конечно, использование вложенных контейнеров, например, непосредственно в инициализаторе Addressизлишне связывает вас с декодированием объекта JSON, который начинается в определенном месте в графе родительских объектов. Было бы намного лучше абстрагироваться от начального пути ключа до самого декодера - вот грубая хакерская реализация .
Хэмиш
17

В Swift 4.2, в соответствии с вашими потребностями, вы можете использовать одну из трех следующих стратегий, чтобы имена настраиваемых свойств ваших объектов модели соответствовали вашим JSON-ключам.

№1. Использование пользовательских ключей кодирования

Когда вы объявляете структуру, которая соответствует Codable( Decodableи Encodableпротоколам) со следующей реализацией ...

struct Address: Codable {
    var street: String
    var zip: String
    var city: String
    var state: String        
}

... компилятор автоматически генерирует вложенное перечисление, которое соответствует CodingKeyпротоколу для вас.

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

Следовательно, если ключи, используемые в вашем формате сериализованных данных, не соответствуют именам свойств из вашего типа данных, вы можете вручную реализовать это перечисление и установить подходящие rawValueдля требуемых случаев.

В следующем примере показано, как это сделать:

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

Кодировать (заменяя zipсвойство на ключ JSON "zip_code"):

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

Декодирование (замена ключа JSON "zip_code" на zipсвойство):

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. Стратегии кодирования ключей от змеиного футляра в верблюжий футляр

Если JSON имеет змеиные обсаженных ключи , и вы хотите , чтобы преобразовать их в верблюжьих-обсаженных свойства для вашей модели объекта, вы можете установить JSONEncoder«S keyEncodingStrategyи JSONDecoder» s keyDecodingStrategyсвойства .convertToSnakeCase.

В следующем примере показано, как это сделать:

import Foundation

struct Address: Codable {
    var street: String
    var zipCode: String
    var cityName: String
    var state: String
}

Кодировать (преобразование свойств с верблюжьей оболочкой в ​​ключи JSON со змеиным корпусом):

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

Декодирование (преобразование ключей JSON с оболочкой змеи в свойства с оболочкой верблюда):

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. Использование пользовательских стратегий кодирования ключей

Если необходимо, JSONEncoderи JSONDecoderвы можете установить собственную стратегию для сопоставления ключей кодирования с помощью JSONEncoder.KeyEncodingStrategy.custom(_:)и JSONDecoder.KeyDecodingStrategy.custom(_:).

В следующем примере показано, как их реализовать:

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

Кодировать (преобразование свойств первой буквы в нижнем регистре в ключи JSON с первой буквой в верхнем регистре):

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

Декодирование (преобразование ключей JSON с первой буквой в верхнем регистре в свойства первой буквы в нижнем регистре):

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

Источники:

Иману Пети
источник
3

Я создал собственную структуру, аналогичную той, которую вы получаете от JSON, в отношении его типов данных.

Именно так:

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
}

После этого вам нужно создать расширение того же structрасширения decodableи той enumже структуры с, CodingKeyа затем вам нужно инициализировать декодер, используя это перечисление с его ключами и типами данных (ключи будут поступать из перечисления, а типы данных будут приходить или говорить ссылка на саму структуру)

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

Здесь вам нужно изменить каждый ключ и типы данных в соответствии с вашими потребностями и использовать их с декодером.

Тушар
источник
-1

Используя CodingKey, вы можете использовать собственные ключи в кодируемом или декодируемом протоколе.

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
    } }
Ренджиш С
источник