在Swift 4中更新多种类型的标签

Question

I have an API that will sometimes return a specific key in the JSON as an Int and other times it will return that same key as a String, I solve this issue by creating an enum IntOrString. Now the issue is when I call the API to update the label of these specific key the type is wrong.

Then I'm getting the error cannot convert type Double to type DoubleOrString

enum DoubleOrString: Codable {

    case double(Double)
    case string(String)

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        do {
            self = try .double(container.decode(Double.self))
        } catch DecodingError.typeMismatch {
            do {
                self = try .string(container.decode(String.self))
            } catch DecodingError.typeMismatch {
                throw DecodingError.typeMismatch(
                    DoubleOrString.self,
                    DecodingError.Context(
                        codingPath: decoder.codingPath,
                        debugDescription: "Encoded payload conflicts with expected type, (Double or String)"
                    )
                )
            }
        }
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .double(let double):
            try container.encode(double)
        case .string(let string):
            try container.encode(string)
        }
    }
}

Lower down this is where I'm updating my label

self.ageLabel.text = "\(pData.info.detailedInfo?.ageNumber ?? 0.0)"

Answer 1

First, I think you should decide if you really want to keep this as a DoubleOrString throughout the program. Do you need to keep track of the distinction? Or could you modify your decoder to always make this a double? Your internal data model doesn't have to recreate every mistake in the JSON.

If you do want to maintain the enum, then I think what you're looking for is something along these lines:

extension DoubleOrString {
    var doubleValue: Double? {
        switch self {
        case .double(let double): return double
        case .string(let string): return Double(string)
        }
    }
}

self.ageLabel.text = "\(pData.info.detailedInfo?.ageNumber.doubleValue ?? 0.0)"

(Of course the preferred solution here is to correct the JSON so that it returns consistent types. I recognize that this is not always an available option.)

---

If you want to eliminate DoubleOrString, which is usually a good idea, then move up a level in your structure, and decode age this way:

guard let age = try
    (try? container.decode(Double.self, forKey: .age)) ??
    Double(container.decode(String.self, forKey: .age))
    else {
        throw DecodingError.typeMismatch(Double.self,
                                         DecodingError.Context(
                                            codingPath: decoder.codingPath,
                                            debugDescription: "Encoded payload conflicts with expected type, (Double or String)"))
}
self.age = age

This tries to decode it as a double, and if that fails, it tries converting a string value. This will still helpfully throw the right errors if the key is missing, without needing a bunch of do/catch blocks.

If you have a lot of this, you could wrap it up this way:

struct JSONDouble: Codable {
    let value: Double

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        guard let value = try
            (try? container.decode(Double.self)) ??
            Double(container.decode(String.self))
            else {
                throw DecodingError.typeMismatch(Double.self,
                                                 DecodingError.Context(
                                                    codingPath: decoder.codingPath,
                                                    debugDescription: "Encoded payload conflicts with expected type, (Double or String)"))
        }
        self.value = value
    }
}

Then your decoding logic is just:

self.age = try container.decode(JSONDouble.self, forKey: .age).value

Answer 2

Do you need to use an enum?

If that is not the case you can easily use Generics for this issue.

With generics you can use multiple datatypes.