147

在使用 Swift4 和 Codable 协议时，我遇到了以下问题 - 看起来没有办法允许JSONDecoder跳过数组中的元素。例如，我有以下 JSON：

[
    {
        "name": "Banana",
        "points": 200,
        "description": "A banana grown in Ecuador."
    },
    {
        "name": "Orange"
    }
]

还有一个Codable结构：

struct GroceryProduct: Codable {
    var name: String
    var points: Int
    var description: String?
}

解码此 json 时

let decoder = JSONDecoder()
let products = try decoder.decode([GroceryProduct].self, from: json)

结果products为空。这是意料之中的，因为 JSON 中的第二个对象没有"points"键，而在structpoints中不是可选的。GroceryProduct

问题是如何允许JSONDecoder“跳过”无效对象？

4

16 回答 16

151

一种选择是使用尝试解码给定值的包装器类型；nil如果不成功则存储：

struct FailableDecodable<Base : Decodable> : Decodable {

    let base: Base?

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        self.base = try? container.decode(Base.self)
    }
}

然后我们可以解码这些数组，并GroceryProduct填写Base占位符：

import Foundation

let json = """
[
    {
        "name": "Banana",
        "points": 200,
        "description": "A banana grown in Ecuador."
    },
    {
        "name": "Orange"
    }
]
""".data(using: .utf8)!


struct GroceryProduct : Codable {
    var name: String
    var points: Int
    var description: String?
}

let products = try JSONDecoder()
    .decode([FailableDecodable<GroceryProduct>].self, from: json)
    .compactMap { $0.base } // .flatMap in Swift 4.0

print(products)

// [
//    GroceryProduct(
//      name: "Banana", points: 200,
//      description: Optional("A banana grown in Ecuador.")
//    )
// ]

然后我们.compactMap { $0.base }用来过滤掉nil元素（那些在解码时抛出错误的元素）。

这将创建一个中间数组[FailableDecodable<GroceryProduct>]，这应该不是问题；但是，如果您希望避免这种情况，您始终可以创建另一种包装器类型，该包装器类型从无键容器中解码和解包每个元素：

struct FailableCodableArray<Element : Codable> : Codable {

    var elements: [Element]

    init(from decoder: Decoder) throws {

        var container = try decoder.unkeyedContainer()

        var elements = [Element]()
        if let count = container.count {
            elements.reserveCapacity(count)
        }

        while !container.isAtEnd {
            if let element = try container
                .decode(FailableDecodable<Element>.self).base {

                elements.append(element)
            }
        }

        self.elements = elements
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(elements)
    }
}

然后，您将解码为：

let products = try JSONDecoder()
    .decode(FailableCodableArray<GroceryProduct>.self, from: json)
    .elements

print(products)

// [
//    GroceryProduct(
//      name: "Banana", points: 200,
//      description: Optional("A banana grown in Ecuador.")
//    )
// ]
于 2017-09-22T16:20:18.727 回答
49

我会创建一个新类型Throwable，它可以包装任何符合以下条件的类型Decodable：

enum Throwable<T: Decodable>: Decodable {
    case success(T)
    case failure(Error)

    init(from decoder: Decoder) throws {
        do {
            let decoded = try T(from: decoder)
            self = .success(decoded)
        } catch let error {
            self = .failure(error)
        }
    }
}

GroceryProduct用于解码（或任何其他Collection）数组：

let decoder = JSONDecoder()
let throwables = try decoder.decode([Throwable<GroceryProduct>].self, from: json)
let products = throwables.compactMap { $0.value }

其中value是在扩展中引入的计算属性Throwable：

extension Throwable {
    var value: T? {
        switch self {
        case .failure(_):
            return nil
        case .success(let value):
            return value
        }
    }
}

我会选择使用enum包装器类型（超过 a Struct），因为跟踪抛出的错误及其索引可能很有用。

斯威夫特 5

对于 Swift 5 考虑使用例如Result enum

struct Throwable<T: Decodable>: Decodable {
    let result: Result<T, Error>

    init(from decoder: Decoder) throws {
        result = Result(catching: { try T(from: decoder) })
    }
}

要解开解码的值，请使用属性get()上的方法result：

let products = throwables.compactMap { try? $0.result.get() }
于 2018-08-29T06:08:50.787 回答
27

问题是在迭代容器时， container.currentIndex 不会递增，因此您可以尝试使用不同的类型再次解码。

因为 currentIndex 是只读的，所以一个解决方案是自己增加它，成功解码一个虚拟对象。我采用了@Hamish 解决方案，并使用自定义初始化编写了一个包装器。

这个问题是当前的 Swift 错误：https ://bugs.swift.org/browse/SR-5953

此处发布的解决方案是其中一条评论中的解决方法。我喜欢这个选项，因为我在网络客户端上以相同的方式解析一堆模型，并且我希望解决方案是其中一个对象的本地解决方案。也就是说，我仍然希望其他人被丢弃。

我在我的 github https://github.com/phynet/Lossy-array-decode-swift4中解释得更好

import Foundation

    let json = """
    [
        {
            "name": "Banana",
            "points": 200,
            "description": "A banana grown in Ecuador."
        },
        {
            "name": "Orange"
        }
    ]
    """.data(using: .utf8)!

    private struct DummyCodable: Codable {}

    struct Groceries: Codable 
    {
        var groceries: [GroceryProduct]

        init(from decoder: Decoder) throws {
            var groceries = [GroceryProduct]()
            var container = try decoder.unkeyedContainer()
            while !container.isAtEnd {
                if let route = try? container.decode(GroceryProduct.self) {
                    groceries.append(route)
                } else {
                    _ = try? container.decode(DummyCodable.self) // <-- TRICK
                }
            }
            self.groceries = groceries
        }
    }

    struct GroceryProduct: Codable {
        var name: String
        var points: Int
        var description: String?
    }

    let products = try JSONDecoder().decode(Groceries.self, from: json)

    print(products)
于 2017-10-12T15:08:37.943 回答
24

有两种选择：

  1. 将结构的所有成员声明为可缺少其键的可选成员

    struct GroceryProduct: Codable {
    var name: String
    var points : Int?
    var description: String?
}

  2. nil编写自定义初始化程序以在案例中分配默认值。

    struct GroceryProduct: Codable {
    var name: String
    var points : Int
    var description: String

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        name = try values.decode(String.self, forKey: .name)
        points = try values.decodeIfPresent(Int.self, forKey: .points) ?? 0
        description = try values.decodeIfPresent(String.self, forKey: .description) ?? ""
    }
}
于 2017-09-22T13:23:06.847 回答
17

Swift 5.1 使用属性包装器实现的解决方案：

@propertyWrapper
struct IgnoreFailure<Value: Decodable>: Decodable {
    var wrappedValue: [Value] = []

    private struct _None: Decodable {}

    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        while !container.isAtEnd {
            if let decoded = try? container.decode(Value.self) {
                wrappedValue.append(decoded)
            }
            else {
                // item is silently ignored.
                try? container.decode(_None.self)
            }
        }
    }
}

然后是用法：

let json = """
{
    "products": [
        {
            "name": "Banana",
            "points": 200,
            "description": "A banana grown in Ecuador."
        },
        {
            "name": "Orange"
        }
    ]
}
""".data(using: .utf8)!

struct GroceryProduct: Decodable {
    var name: String
    var points: Int
    var description: String?
}

struct ProductResponse: Decodable {
    @IgnoreFailure
    var products: [GroceryProduct]
}


let response = try! JSONDecoder().decode(ProductResponse.self, from: json)
print(response.products) // Only contains banana.

注意：属性包装器仅在响应可以包装在结构中时才有效（即：不是顶级数组）。在这种情况下，您仍然可以手动包装它（使用 typealias 以获得更好的可读性）：

typealias ArrayIgnoringFailure<Value: Decodable> = IgnoreFailure<Value>

let response = try! JSONDecoder().decode(ArrayIgnoringFailure<GroceryProduct>.self, from: json)
print(response.wrappedValue) // Only contains banana.
于 2019-10-04T10:15:08.560 回答
8

我已经将@sophy-swicz 解决方案，经过一些修改，放入一个易于使用的扩展中

fileprivate struct DummyCodable: Codable {}

extension UnkeyedDecodingContainer {

    public mutating func decodeArray<T>(_ type: T.Type) throws -> [T] where T : Decodable {

        var array = [T]()
        while !self.isAtEnd {
            do {
                let item = try self.decode(T.self)
                array.append(item)
            } catch let error {
                print("error: \(error)")

                // hack to increment currentIndex
                _ = try self.decode(DummyCodable.self)
            }
        }
        return array
    }
}
extension KeyedDecodingContainerProtocol {
    public func decodeArray<T>(_ type: T.Type, forKey key: Self.Key) throws -> [T] where T : Decodable {
        var unkeyedContainer = try self.nestedUnkeyedContainer(forKey: key)
        return try unkeyedContainer.decodeArray(type)
    }
}

就这样称呼它

init(from decoder: Decoder) throws {

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

    self.items = try container.decodeArray(ItemType.self, forKey: . items)
}

对于上面的例子：

let json = """
[
    {
        "name": "Banana",
        "points": 200,
        "description": "A banana grown in Ecuador."
    },
    {
        "name": "Orange"
    }
]
""".data(using: .utf8)!

struct Groceries: Codable 
{
    var groceries: [GroceryProduct]

    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        groceries = try container.decodeArray(GroceryProduct.self)
    }
}

struct GroceryProduct: Codable {
    var name: String
    var points: Int
    var description: String?
}

let products = try JSONDecoder().decode(Groceries.self, from: json)
print(products)
于 2018-04-06T04:30:19.267 回答
5

相反，您也可以这样做：

struct GroceryProduct: Decodable {
    var name: String
    var points: Int
    var description: String?
}'

然后在得到它的时候：

'let groceryList = try JSONDecoder().decode(Array<GroceryProduct>.self, from: responseData)'
于 2020-07-20T00:39:13.783 回答
4

不幸的是，Swift 4 API 没有用于init(from: Decoder).

我看到的只有一种解决方案是实现自定义解码，为可选字段提供默认值，并为所需数据提供可能的过滤器：

struct GroceryProduct: Codable {
    let name: String
    let points: Int?
    let description: String

    private enum CodingKeys: String, CodingKey {
        case name, points, description
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decode(String.self, forKey: .name)
        points = try? container.decode(Int.self, forKey: .points)
        description = (try? container.decode(String.self, forKey: .description)) ?? "No description"
    }
}

// for test
let dict = [["name": "Banana", "points": 100], ["name": "Nut", "description": "Woof"]]
if let data = try? JSONSerialization.data(withJSONObject: dict, options: []) {
    let decoder = JSONDecoder()
    let result = try? decoder.decode([GroceryProduct].self, from: data)
    print("rawResult: \(result)")

    let clearedResult = result?.filter { $0.points != nil }
    print("clearedResult: \(clearedResult)")
}
于 2017-09-22T13:12:55.900 回答
4

我针对这种情况改进了@Hamish，您希望所有数组都具有这种行为：

private struct OptionalContainer<Base: Codable>: Codable {
    let base: Base?
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        base = try? container.decode(Base.self)
    }
}

private struct OptionalArray<Base: Codable>: Codable {
    let result: [Base]
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let tmp = try container.decode([OptionalContainer<Base>].self)
        result = tmp.compactMap { $0.base }
    }
}

extension Array where Element: Codable {
    init(from decoder: Decoder) throws {
        let optionalArray = try OptionalArray<Element>(from: decoder)
        self = optionalArray.result
    }
}
于 2019-09-20T13:28:20.630 回答
2

@Hamish 的回答很棒。但是，您可以减少FailableCodableArray到：

struct FailableCodableArray<Element : Codable> : Codable {

    var elements: [Element]

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let elements = try container.decode([FailableDecodable<Element>].self)
        self.elements = elements.compactMap { $0.wrapped }
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(elements)
    }
}
于 2018-11-24T20:56:57.230 回答
2

我最近遇到了类似的问题，但略有不同。

struct Person: Codable {
    var name: String
    var age: Int
    var description: String?
    var friendnamesArray:[String]?
}

在这种情况下，如果其中一个元素friendnamesArray为 nil，则在解码时整个对象为 nil。

处理这种极端情况的正确方法是将字符串数组声明[String]为可选字符串数组，[String?]如下所示，

struct Person: Codable {
    var name: String
    var age: Int
    var description: String?
    var friendnamesArray:[String?]?
}
于 2019-03-30T05:56:26.457 回答
2

您将描述设为可选，如果有可能为 nil，您还应该将 points 字段设为可选，例如：

struct GroceryProduct: Codable {
    var name: String
    var points: Int?
    var description: String?
}

只要确保您安全地打开它，但您认为它适合它的使用。我猜在实际用例中 nil points == 0 所以一个例子可能是：

let products = try JSONDecoder().decode([GroceryProduct].self, from: json)
for product in products {
    let name = product.name
    let points = product.points ?? 0
    let description = product.description ?? ""
    ProductView(name, points, description)
}

或在线：

let products = try JSONDecoder().decode([GroceryProduct].self, from: json)
for product in products {
    ProductView(product.name, product.points ?? 0, product.description ?? "")
}
于 2021-12-13T21:46:18.593 回答
1

我想出了KeyedDecodingContainer.safelyDecodeArray一个提供简单界面的方法：

extension KeyedDecodingContainer {

/// The sole purpose of this `EmptyDecodable` is allowing decoder to skip an element that cannot be decoded.
private struct EmptyDecodable: Decodable {}

/// Return successfully decoded elements even if some of the element fails to decode.
func safelyDecodeArray<T: Decodable>(of type: T.Type, forKey key: KeyedDecodingContainer.Key) -> [T] {
    guard var container = try? nestedUnkeyedContainer(forKey: key) else {
        return []
    }
    var elements = [T]()
    elements.reserveCapacity(container.count ?? 0)
    while !container.isAtEnd {
        /*
         Note:
         When decoding an element fails, the decoder does not move on the next element upon failure, so that we can retry the same element again
         by other means. However, this behavior potentially keeps `while !container.isAtEnd` looping forever, and Apple does not offer a `.skipFailable`
         decoder option yet. As a result, `catch` needs to manually skip the failed element by decoding it into an `EmptyDecodable` that always succeed.
         See the Swift ticket https://bugs.swift.org/browse/SR-5953.
         */
        do {
            elements.append(try container.decode(T.self))
        } catch {
            if let decodingError = error as? DecodingError {
                Logger.error("\(#function): skipping one element: \(decodingError)")
            } else {
                Logger.error("\(#function): skipping one element: \(error)")
            }
            _ = try? container.decode(EmptyDecodable.self) // skip the current element by decoding it into an empty `Decodable`
        }
    }
    return elements
}
}

潜在的无限循环while !container.isAtEnd是一个问题，可以通过使用EmptyDecodable.

于 2018-10-21T04:08:02.377 回答
1

一个更简单的尝试：为什么不将点声明为可选或使数组包含可选元素

let products = [GroceryProduct?]
于 2018-11-09T22:05:27.807 回答
1

斯威夫特 5

受先前答案的启发，我在 Result 枚举扩展中解码。

你怎么看待这件事？


extension Result: Decodable where Success: Decodable, Failure == DecodingError {

    public init(from decoder: Decoder) throws {

        let container: SingleValueDecodingContainer = try decoder.singleValueContainer()

        do {

            self = .success(try container.decode(Success.self))

        } catch {

            if let decodingError = error as? DecodingError {
                self = .failure(decodingError)
            } else {
                self = .failure(DecodingError.dataCorrupted(.init(codingPath: [], debugDescription: error.localizedDescription)))
            }
        }
    }
    
}

用法


let listResult = try? JSONDecoder().decode([Result<SomeObject, DecodingError>].self, from: ##YOUR DATA##)

let list: [SomeObject] = listResult.compactMap {try? $0.get()}
于 2021-02-05T15:21:31.110 回答
0

特征：

  • 使用简单。Decodable 实例中的一行：let array: CompactDecodableArray<Int>
  • 用标准映射机制解码：JSONDecoder().decode(Model.self, from: data)
  • 跳过不正确的元素（返回只有成功映射元素的数组）

细节

  • Xcode 12.1 (12A7403)
  • 斯威夫特 5.3

解决方案

class CompactDecodableArray<Element>: Decodable where Element: Decodable {
    private(set) var elements = [Element]()
    required init(from decoder: Decoder) throws {
        guard var unkeyedContainer = try? decoder.unkeyedContainer() else { return }
        while !unkeyedContainer.isAtEnd {
            if let value = try? unkeyedContainer.decode(Element.self) {
                elements.append(value)
            } else {
                unkeyedContainer.skip()
            }
        }
    }
}

// https://forums.swift.org/t/pitch-unkeyeddecodingcontainer-movenext-to-skip-items-in-deserialization/22151/17

struct Empty: Decodable { }

extension UnkeyedDecodingContainer {
    mutating func skip() { _ = try? decode(Empty.self) }
}

用法

struct Model2: Decodable {
    let num: Int
    let str: String
}

struct Model: Decodable {
    let num: Int
    let str: String
    let array1: CompactDecodableArray<Int>
    let array2: CompactDecodableArray<Int>?
    let array4: CompactDecodableArray<Model2>
}

let dictionary: [String : Any] = ["num": 1, "str": "blablabla",
                                  "array1": [1,2,3],
                                  "array3": [1,nil,3],
                                  "array4": [["num": 1, "str": "a"], ["num": 2]]
]

let data = try! JSONSerialization.data(withJSONObject: dictionary)
let object = try JSONDecoder().decode(Model.self, from: data)
print("1. \(object.array1.elements)")
print("2. \(object.array2?.elements)")
print("3. \(object.array4.elements)")

安慰

1. [1, 2, 3]
2. nil
3. [__lldb_expr_25.Model2(num: 1, str: "a")]
于 2020-10-22T16:29:43.163 回答