如何检查由不同结构组成的两个数组是否具有相同的值？

Question

我有两个由不同结构组成的数组，它们在数组的不同位置都有相同的信息。

我尝试使用 if 语句创建一个双 for-in 循环来检查它们是否是相同的值，但是我在 PHP 等其他语言中执行此操作的方式不起作用。

请帮帮我，这是我目前所得到的：

单一文件

struct oneStruct {
    var oneTitle: String
    var onePic: UIImage?
    var oneCategory: String
}

class OneSingleton {
    static let sharedInstance = OneSingleton()
    private init() {}
    var oneArray: [OneStruct] = [//you get the gist, this is full of array stuff]
}

单两个文件

struct TwoStruct {
    var twoName: String
    var twoPic: UIImage?
    var twoSubject: String
    var twoStuff1: String
    // etc. I can't get into much more here, sorry.
}

class TwoSingleton {
    static let sharedInstance = TwoSingleton()
    private init() {}
    var twoArray: [TwoStruct] = [//you get the gist, this is full of array stuff as well]
}

视图控制器

//the singleton stuff is needed

var oneArray = [OneSingleton.sharedInstance.oneArray]
var twoArray = [TwoSingleton.sharedInstance.twoArray]
var filterArray: [TwoStruct] = []

override func viewDidLoad() {
    super.viewDidLoad()

    for two in twoArray {
        for one in oneArray {
            if two == one {
                filterArray.append(contentsOf: two)
            }
        }
    }
}

它给了我一个编译错误

二元运算符“==”不能应用于“[TwoStruct]”和“[OneStruct]”类型的操作数

我希望这一切都有意义。

提前致谢。

Answer 1

比较两者的实现Equatable 并将 lhs 或 rhs 更改为另一个对象

struct OneStruct :Equatable {

    var value1: String
    var value2: UIImage? /// image comparsion is not an easy way you may add id of image
    var value3: String

   // also you can omit any static method part from any class 

    static func ==(lhs: TwoStruct, rhs: OneStruct) -> Bool {
        return lhs.value1 == rhs.value1 && lhs.value3 == rhs.value3
    }

}

struct TwoStruct :Equatable {

    var value1: String
    var value2: UIImage? /// image comparsion is not an easy way you may add id of image
    var value3: String

    // also you can omit any static method part from any class 

    static func ==(lhs: OneStruct, rhs: TwoStruct) -> Bool {
        return lhs.value1 == rhs.value1 && lhs.value3 == rhs.value3
    }
 }    

//

let s1 = OneStruct(value1: "", value2: UIImage.init(named: ""), value3: "")
let s2 = TwoStruct(value1: "", value2: UIImage.init(named: ""), value3: "")

if s1 == s2 {


}

Answer 2

对于OneStruct 和TwoStruct 的每一种类型，您似乎都有一个您想用于比较的属性； category 和 subject，分别。因此，首先，让我们为这两个属性绘制两个协议：

protocol Categorizable {
    var category: String { get }
}

protocol Subjectable {
    var subject: String { get }
}

就本示例而言，OneStruct 和 TwoStruct 的最小示例将分别符合 Categorizable 和 Subjectable：

struct OneStruct: Categorizable {
    var category: String
    init(_ category: String) { self.category = category }
}

struct TwoStruct: Subjectable {
    var subject: String
    init(_ subject: String) { self.subject = subject }
}

现在，在比较两种不同类型时，我们真的不想谈论平等，而是可以比较这两种类型的实例的等价类或双谓词。所以让我们定义例如一个双谓词，可用于比较两个分别符合Categorizable 和Subjectable 的实例：

struct BiPredicate<T: Categorizable, U: Subjectable> {
    static func compare(_ lhs: T, _ rhs: U) -> Bool {
        return lhs.category == rhs.subject
    }
    static func compare(_ lhs: U, _ rhs: T) -> Bool {
        return compare(rhs, lhs)
    }
}

根据您自己的示例代码，您似乎希望根据数组中的每个元素是否存在两个过滤TwoStruct的数组（即符合Subjectable的类型的数组） OneStruct 数组（即符合Categorizable 类型的数组）中的一个成员，其等价类或双谓词成立。

/// Returns `lhs` argument filtered based on its BiPredicate intersection
/// with the `rhs` argument.
/// Time complexity: O(n^2)
func filterByIntersect<T: Subjectable, U: Categorizable>(_ lhs: [T], over rhs: [U]) -> [T] {
    return lhs.filter { l in rhs.contains { r in BiPredicate.compare(l, r) } }
}

我们可以用作：

let oneArray = [OneStruct("foo"), OneStruct("bar"), OneStruct("baz"), OneStruct("bax")]
let twoArray = [TwoStruct("baxx"), TwoStruct("foo"), TwoStruct("bax")]

let result = filterByIntersect(twoArray, over: oneArray)
for twoElement in result { print(twoElement.subject) } /* foo
                                                          bax */

---

现在，这主要是一个有点有趣的练习，但最终以相当多的样板代码结束，这应该是一个相当简单的任务。你总是可以放弃泛型，只使用一个简单的函数来测试OneStruct 和TwoStruct 上的单个等效类：

func compareCategoryWithSubject(_ lhs: OneStruct, _ rhs: TwoStruct) -> Bool {
    return lhs.category == rhs.subject
}

/// Returns `lhs` argument filtered based on intersection over comparing 
/// the `subject` properties of the elements of `lhs` with the `category`
/// properties of the elements of `rhs`.
/// Time complexity: O(n^2)
func filterByIntersect(_ lhs: [TwoStruct], over rhs: [OneStruct]) -> [TwoStruct] {
    return lhs.filter { l in rhs.contains { r in
        compareCategoryWithSubject(r, l) } }
}

或者，对于一种可能更简单且渐进性更高的方法，将所有逻辑放入 filterByIntersect(...) 函数中：

/// Returns `lhs` argument filtered based on intersection over comparing
/// the `subject` properties of the elements of `lhs` with the `category`
/// properties of the elements of `rhs`.
/// Time complexity: O(n) [contains(_:) is O(1) for Set)
func filterByIntersect(_ lhs: [TwoStruct], over rhs: [OneStruct]) -> [TwoStruct] {
    let rhsCategories = Set(rhs.map { $0.category })
    return lhs.filter { l in rhsCategories.contains(l.subject) }
}

以上两种方法都产生与上述相同的结果：

let oneArray = [OneStruct("foo"), OneStruct("bar"), OneStruct("baz"), OneStruct("bax")]
let twoArray = [TwoStruct("baxx"), TwoStruct("foo"), TwoStruct("bax")]

let result = filterByIntersect(twoArray, over: oneArray)
for twoElement in result { print(twoElement.subject) } /* foo
                                                          bax */