Swift 4 JSON décodable la façon la plus simple de décoder le changement de type

Vous pouvez toujours décoder manuellement. Donc, étant donné:

{
    "name": "Bob",
    "age": 25,
    "tax_rate": "4.25"
}

Vous pouvez faire:

struct Example: Codable {
    let name: String
    let age: Int
    let taxRate: Float

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        name = try values.decode(String.self, forKey: .name)
        age = try values.decode(Int.self, forKey: .age)
        guard let rate = try Float(values.decode(String.self, forKey: .taxRate)) else {
            throw DecodingError.dataCorrupted(.init(codingPath: [CodingKeys.taxRate], debugDescription: "Expecting string representation of Float"))
        }
        taxRate = rate
    }

    enum CodingKeys: String, CodingKey {
        case name, age
        case taxRate = "tax_rate"
    }
}

Voir Encoder et décoder manuellementencodage et décodage des types personnalisés.

mais je suis d'accord, qu'il semble qu'il devrait y avoir un processus de conversion de chaîne plus élégant équivalent à DateDecodingStrategy étant donné combien de sources JSON là-bas renvoient incorrectement des valeurs numériques sous forme de chaînes.

en Fonction de vos besoins, vous pouvez choisir l'une des deux manières suivantes afin de résoudre votre problème.

#1. En utilisant Decodableinit(from:) initialisation

utilisez cette stratégie lorsque vous avez besoin de convertir de StringFloat pour une seule structure, enum ou classe.

import Foundation

struct ExampleJson: Decodable {

    var name: String
    var age: Int
    var taxRate: Float

    enum CodingKeys: String, CodingKey {
        case name, age, taxRate = "tax_rate"
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)

        name = try container.decode(String.self, forKey: CodingKeys.name)
        age = try container.decode(Int.self, forKey: CodingKeys.age)
        let taxRateString = try container.decode(String.self, forKey: CodingKeys.taxRate)
        guard let taxRateFloat = Float(taxRateString) else {
            let context = DecodingError.Context(codingPath: container.codingPath + [CodingKeys.taxRate], debugDescription: "Could not parse json key to a Float object")
            throw DecodingError.dataCorrupted(context)
        }
        taxRate = taxRateFloat
    }

}

Utilisation:

import Foundation

let jsonString = """
{
  "name": "Bob",
  "age": 25,
  "tax_rate": "4.25"
}
"""

let data = jsonString.data(using: String.Encoding.utf8)!
let decoder = JSONDecoder()
let exampleJson = try! decoder.decode(ExampleJson.self, from: data)
dump(exampleJson)
/*
 prints:
 ▿ __lldb_expr_126.ExampleJson
   - name: "Bob"
   - age: 25
   - taxRate: 4.25
 */

#2. Utilisation d'un modèle intermédiaire

utilisez cette stratégie lorsque vous avez beaucoup de clés imbriquées dans votre JSON ou quand vous avez besoin de convertir beaucoup de clés (par exemple de StringFloat) de votre JSON.

import Foundation

fileprivate struct PrivateExampleJson: Decodable {

    var name: String
    var age: Int
    var taxRate: String

    enum CodingKeys: String, CodingKey {
        case name, age, taxRate = "tax_rate"
    }

}

struct ExampleJson: Decodable {

    var name: String
    var age: Int
    var taxRate: Float

    init(from decoder: Decoder) throws {
        let privateExampleJson = try PrivateExampleJson(from: decoder)

        name = privateExampleJson.name
        age = privateExampleJson.age
        guard let convertedTaxRate = Float(privateExampleJson.taxRate) else {
            let context = DecodingError.Context(codingPath: [], debugDescription: "Could not parse json key to a Float object")
            throw DecodingError.dataCorrupted(context)
        }
        taxRate = convertedTaxRate
    }

}

Utilisation:

import Foundation

let jsonString = """
{
  "name": "Bob",
  "age": 25,
  "tax_rate": "4.25"
}
"""

let data = jsonString.data(using: String.Encoding.utf8)!
let decoder = JSONDecoder()
let exampleJson = try! decoder.decode(ExampleJson.self, from: data)
dump(exampleJson)
/*
 prints:
 ▿ __lldb_expr_126.ExampleJson
   - name: "Bob"
   - age: 25
   - taxRate: 4.25
 */

Vous pouvez utiliser lazy var pour convertir la propriété en un autre type:

struct ExampleJson: Decodable {
    var name: String
    var age: Int
    lazy var taxRate: Float = {
        Float(self.tax_rate)!
    }()

    private var tax_rate: String
}

Un inconvénient de cette approche est que vous ne pouvez pas définir un let constante si vous souhaitez accéder à taxRate, depuis la première fois que vous y accédez, vous êtes en train de muter la structure.

// Cannot use `let` here
var example = try! JSONDecoder().decode(ExampleJson.self, from: data)

je sais que c'est vraiment une réponse tardive, mais j'ai commencé à travailler sur Codable quelques jours seulement. Et je suis tombé sur un problème similaire.

afin de convertir la chaîne en nombre flottant, vous pouvez écrire une extension KeyedDecodingContainer et l'appel à la méthode dans l'extension de init(from decoder: Decoder){}

Pour le problème évoqué dans cette question, voir l'extension que j'ai écrit ci-dessous;

extension KeyedDecodingContainer {

func decodeIfPresent(_ type: Float.Type, forKey key: K, transformFrom: String.Type) throws -> Float? {

        guard let value = try decodeIfPresent(transformFrom, forKey: key) else {
            return nil
        }
        return Float(value)
    }

func decode(_ type: Float.Type, forKey key: K, transformFrom: String.Type) throws -> Float? {

         return Float(try decode(transformFrom, forKey: key))
    }
}

vous pouvez appeler cette méthode de init(from decoder: Decoder) méthode. Voir un exemple ci-dessous;

init(from decoder: Decoder) throws {

    let container = try decoder.container(keyedBy: CodingKeys.self)

    taxRate = try container.decodeIfPresent(Float.self, forKey: .taxRate, transformFrom: String.self)
}

En fait, vous pouvez utiliser cette méthode pour convertir n'importe quel type de données d'un autre type. Vous pouvez convertir string to Date,string to bool,string to float,float to int etc.

en fait pour convertir une chaîne en objet Date, je préfère cette approche à JSONEncoder().dateEncodingStrategy parce que si vous l'écrivez correctement, vous pouvez inclure différents formats de date dans la même réponse.

J'espère avoir aidé.

entrez la description du lien ici comment utiliser JSONDecodable dans Swift4

1) Obtenir la réponse JSON et créer Struct 2) classe de conform décodable dans la structure 3) autres étapes à suivre(exemple Simple)