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并拥有skills Java或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
}

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 {
        for filter in self where filter.matches(p) { return true }
        return false
    }

    func matchesAll(_ p: Person) -> Bool {
        for filter in self where !filter.matches(p) { return false }
        return true
    }
}

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 OR C＃）

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

1 个答案: