Question

在Swift 4中，我有：

let customers = [Customer(name: "John", country: "US", profession: "Engineer"), Customer(name: "Mary", country: "UK", profession: "Nurse"), Customer(name: "Diana", country: "US", profession: "Engineer"), Customer(name: "Paul", country: "US", profession: "Plumber"), Customer(name: "Sam", country: "UK", profession: "Nurse")]

我希望有一个函数可以过滤customers中的元素，这样每次其中至少2个元素的名称和行业相等时，它们都会被添加到自动创建的数组中通过这个功能：

var customers1 = [Customer(name: "John", country: "US", profession: "Engineer"), Customer(name: "Diana", country: "US", profession: "Engineer")]
var customers2 = [Customer(name: "Mary", country: "UK", profession: "Nurse"), Customer(name: "Sam", country: "UK", profession: "Nurse")]

我没有成功搜索，但是我选择了一些可能适合这种情况的解决方案：

extension Array where Element: Comparable {
    func containsSameElements(as other: [Element]) -> Bool {
        return self[1] == other[1] && self[2] == other[2]
    }
}

或

func ==<Element : Equatable> (lhs: [[Element]], rhs: [[Element]]) -> Bool {
    return lhs.elementsEqual(rhs, by: ==)
}

或

带有循环的

elementsEqual() / contains()。

或

flatMap() / reduce() / filter()的组合。

谢谢。

Answer 1

根据您的反馈和澄清，我会做这样的事情。

struct CountryAndProfession: Hashable, CustomStringConvertible {

    let country: String
    let profession: String


    var description: String {
        return "CountryAndProfession{country: \(country), profession: \(profession)}"
    }

    var hashValue: Int {
        return "\(country)__\(profession)".hashValue
    }
    static func ==(left: CountryAndProfession, right: CountryAndProfession) -> Bool {
        return left.country == right.country && left.profession == right.profession
    }
}

// The Customer Type you apparently are dealing with. (May need a custom init depending on your use case
struct Customer: CustomStringConvertible {
    let name: String
    let countryAndProfession: CountryAndProfession

    var description: String {
        return "Customer{name: \(name), countryAndProfession: \(countryAndProfession)}"
    }

    // returns a dictionary with the passed customer's CountryAndProfession as the key, and the matching
    static func makeDictionaryWithCountryAndProfession(from customers: [Customer]) -> [CountryAndProfession : [Customer]] {
        var customersArrayDictionary: [CountryAndProfession : [Customer]] = [:]

        customers.forEach { (customer) in
            if customersArrayDictionary.keys.contains(customer.countryAndProfession) {
                customersArrayDictionary[customer.countryAndProfession]?.append(customer)
            }
            else {
                customersArrayDictionary[customer.countryAndProfession] = [customer]
            }
        }
        return customersArrayDictionary
    }

    static func getArraysBasedOnCountries(from customerArray: [Customer]) -> [[Customer]] {
        return Array(makeDictionaryWithCountryAndProfession(from: customerArray).values)
    }
}

let arrayOfArrays = [["John", "A", "A" ], ["Mary", "A", "B" ], ["Diana", "A", "A" ], ["Paul", "B", "B" ], ["Sam", "A", "B" ]]

//If you're dealing with non-predictable data, you should probably have some Optionality
let allCustomers = arrayOfArrays.map{ Customer(name: $0[0], countryAndProfession: CountryAndProfession(country: $0[1], profession: $0[2])) }

let splitCustomers = Customer.getArraysBasedOnCountries(from: allCustomers)
//contains [[John, Diana], [Mary, Sam], [Paul]]

我仍然不太确定你希望你的最终结果是什么样的（总是有助于提出这个问题），但你应该能够得到你正在寻找的结果{{1与您正在寻找或使用makeDictionaryWithCountryAndProfession

的特定CountryAndProfession相结合

Answer 2

这就是我建议你做的事情：

struct Customer {
    let name: String
    let country: String
    let profession: String

    func countryMatches(with otherCustomer: Customer) -> Bool {
        return country == otherCustomer.country
    }

    func professionMatches(with otherCustomer: Customer) -> Bool {
        return profession == otherCustomer.profession
    }

    func countryAndProfessionMatch(with otherCustomer: Customer) -> Bool {
        return countryMatches(with: otherCustomer) && professionMatches(with: otherCustomer)
    }

    static func getAllCustomersWithProfessionsAndCountriesMatching(with customer: Customer, from allCustomers: [Customer]) -> [Customer] {
        return allCustomers.filter { customer.countryAndProfessionMatch(with: $0) }
    }
}

let arrayOfArrays = [["John", "A", "A" ], ["Mary", "A", "B" ], ["Diana", "A", "A" ], ["Paul", "B", "B" ], ["Sam", "A", "B" ]]

//If you're dealing with non-predictable data, you should probably have some Optionality
let allCustomers = arrayOfArrays.map{ Customer(name: $0[0], country: $0[1], profession: $0[2]) }

let allCustomersMatchingJohnProperties = Customer.getAllCustomersWithProfessionsAndCountriesMatching(with: allCustomers[0], from: allCustomers)  
// contains John and Diane

let allCustomersMatchingMaryProperties = Customer.getAllCustomersWithProfessionsAndCountriesMatching(with: allCustomers[1], from: allCustomers)  
// contains Mary and Sam

我相信这会做你想做的事情，但采用更有条理/可维护的方法。

getAllCustomersWithProfessionsAndCountriesMatching几乎肯定太长了，但是这样做就是为了清楚答案。我建议将其重命名以适合您的使用案例。

Swift - 根据它们的相同特征对元素进行分组

2 个答案: