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

Chris 发表于 Dev

克里斯

我正在尝试在我的应用程序中进行一些复杂的过滤，但是到了我不知道下一步该怎么做的地步。字典的阵列，其中在每一个字典的值可以是我的数据consistes 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"]]

在此示例中，我想显示age28岁或24岁且具有skillsJava或Swift的人，这将是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
}

亚历山大-恢复莫妮卡

这是我的处理方式：

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 AND Swift AND C＃）或至少一个（例如，一个人必须知道至少Java或Swift或C＃）

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。