在 Swift 中过滤具有多个条件和类型的对象数组

Question

我正在尝试在我的应用程序中进行一些复杂的过滤，但我已经到了不知道下一步该做什么的地步。我的数据由一组字典组成，其中每个字典中的值可以是String、Int 或[String]。

let person1: [String : Any] = ["first_name" : "John",
                               "last_name" : "Smith",
                               "age" : 21,
                               "skills" : ["C#", "Java", "Swift"]]
let person2: [String : Any] = ["first_name" : "Kim",
                               "last_name" : "Smith",
                               "age" : 28,
                               "skills" : ["Java", "Swift"]]
let person3: [String : Any] = ["first_name" : "Kate",
                               "last_name" : "Bell",
                               "age" : 24,
                               "skills" : ["C#"]]


var people = [person1, person2, person3]

我让用户选择如何过滤这些数据并创建过滤条件字典。这个字典可以有任意数量的键和值。

let filters: [String : [Any]] = ["age" : [28, 24],
                                 "skills" : ["Java", "Swift"]]

在此示例中，我想显示年龄为 age 28 或 24 并且拥有 Java 或 Swift 的 skills 的人，即 person2

这是我目前所拥有的，但它仅适用于 Int 值：

for (key, values) in filters {
    var filteredItems = people.filter {
        var match = false
        for filterValue in values {
            if $0[key] as! Int == filterValue as! Int {
                match = true
                break
            }
            else {
                match = false
            }
        }
        return match
    }
    people = filteredItems
}

Answer 1

我会这样做：

struct Person {
    let firstName: String
    let lastName: String
    let age: Int
    let skills: [String]
    
    enum Filter {
        enum FilterType<T: Hashable> {
            case one(of: [T])
            case all(of: [T])
            
            // Match against a property that's a single value
            func matches(_ value: T) -> Bool {
                switch self {
                    case .one(let filterValues): return filterValues.contains(value)
                    case .all(let filterValues): return filterValues.count == 1 && filterValues[0] == value
                }
            }
            
            // Match against a property that's a list of values
            func matches(_ values: [T]) -> Bool {
                switch self {
                    case .one(let filterValues): return !Set(filterValues).intersection(values).isEmpty
                    case .all(let filterValues): return Set(filterValues).isSuperset(of: values)
                }
            }
        }
        
        case age(is: FilterType<Int>)
        case skills(is: FilterType<String>)
        
        func matches(_ p: Person) -> Bool {
            switch self {
                case .age(let filterValues): return filterValues.matches(p.age)
                case .skills(let filterValues): return filterValues.matches(p.skills)
            }
        }
    }
}

extension Array where Element == Person.Filter {
    func atLeastOneMatch(_ p: Person) -> Bool {
        self.contains(where: { $0.matches(p) })
    }
    
    func matchesAll(_ p: Person) -> Bool {
        self.allSatisfy { $0.matches(p) }
    }
}

let people = [
    Person(
        firstName: "John",
        lastName : "Smith",
        age: 21,
        skills: ["C#", "Java", "Swift"]
    ),
    Person(
        firstName: "Kim",
        lastName : "Smith",
        age: 28,
        skills: ["Java", "Swift"]
    ),
    Person(
        firstName: "Kate",
        lastName: "Bell",
        age: 24,
        skills: ["C#"]
    ),
]


let filters: [Person.Filter] = [
    .age(is: .one(of: [28, 24])),
    .skills(is: .one(of: ["Java", "Swift"])),
]

let peopleWhoMatchAllFilters = people.filter(filters.matchesAll)
print(peopleWhoMatchAllFilters)

let peopleWhoMatchAtLeastOneFilter = people.filter(filters.atLeastOneMatch)
print(peopleWhoMatchAtLeastOneFilter)

我已经扩展了过滤功能，以便能够指定过滤器的所有值是否应该匹配（例如，一个人必须知道 Java、Swift 和 C#）或至少一个（例如，一个人必须至少知道 Java 或Swift 或 C#)