我如何比较结构数组以查看哪些元素不同？

Question

我有两个结构数组，其中包含几个我想比较的双打。

我想将较旧的数组的每个空间与较新的数组进行比较，并查看哪些索引包含两个双精度匹配的结构，并将它们从两个数组的较新的数组中删除。我希望最终结果是一个只有第一个数组中不包含双打的数组。换句话说，两个数组都有不同的集合。

我最初尝试一次遍历每个索引，但是删除索引会弄乱循环。因此，我尝试创建第三个数组以添加不相同的数组，但是我在弄清楚如何有效地找出哪些不相同方面遇到了麻烦。

是否有任何人知道的快速Swift解决方案可以有效地解决此问题？

这是我到目前为止拥有的代码，但是我有点卡在这里，因为结果将与我要寻找的东西相差无几...

if userPosts.count == 0 {
        userPosts = newArrayOfUserPosts
    }
    if newArrayOfUserPosts.count > 0 {
        for currentCount in 0...userPosts.count - 1 {

            for eachElement in 0...newArrayOfUserPosts.count - 1 {

                if newArrayOfUserPosts[eachElement].postLatitude != userPosts[currentCount].postLatitude && newArrayOfUserPosts[eachElement].postLongitude != userPosts[currentCount].postLongitude {

                }
            }
        }
    }

Answer 1

如果我正确理解了您的问题，则可以使用Set和subtract方法来获取数组中的差异。这是使用Set<Int>的示例：

let oldArray = [0, 2, 7, 5, 10]
let newArray = [0, 2, 7, 5, 10, 11, 8, 20]

let oldSet = Set(oldArray)
let newSet = Set(newArray)

Array(newSet.subtract(oldSet)) // [20, 11, 8]

或者如果您想在一行上输入它：

Array(Set(newArray).subtract(Set(oldArray))) // [20, 11, 8]

为此，您需要使您的结构符合Hashable。

有关Set的更多信息，请查看[The Swift Programming Guide: Collection Types。

Answer 2

let firstArray = [1, 2, 3, 4, 5, 6]

let secondArray = [3, 4, 5, 6, 7, 8]

secondArray.filter{!contains(firstArray, $0)} //[7, 8]

这将使用第二个数组，并删除第一个数组中的所有内容。但是，这仅适用于平等的事物。为了使您的结构在其中的某个变量上等于Equatable，您必须根据您认为使两个结构相同的观点来实现==。这是一个例子：

struct Person : Equatable {
  let name: String
  let age: Int
}

func == (leftHandSide: Person, rightHandSide: Person) -> Bool {
  return leftHandSide.name == rightHandSide.name
}

有一个结构，人。您可以在其中输入一个人的名字和年龄。我们可以决定根据他们的姓名来识别人，这就是为什么我们的==函数可以在.name上使用的原因。

这是过滤的工作方式：

let youngBarry = Person(name: "Barry", age: 25)
let joanna = Person(name: "Joanna", age: 32)
let oldBarry = Person(name: "Barry", age: 44)

let firstArray = [youngBarry]

let secondArray = [oldBarry, joanna]

let filteredSecondArray = secondArray.filter{!contains(firstArray, $0)} //Joanna

[当我们要从第二个数组中删除第一个数组中的内容时，我们的==函数将查看oldBarry和youngBarry，并确定它们相同，因此在第二个数组中不包括oldBarry。

现在，如果要在删除时执行更复杂或可变的行为，您仍然可以，因为“包含”可以关闭。这与上面的代码相同，但是没有实现==：

let filteredSecondArray = secondArray.filter{
  secondArrayElement in

  !contains(firstArray) {

    firstArrayElement in

    return secondArrayElement.name == firstArrayElement.name

  }

}

不过，您的用例看起来更适合实现Equatable。这是您要执行的操作。：

extension YourStruct : Equatable {}

func == (lhs: YourStruct, rhs: YourStruct) -> Bool {
  return lhs.postLatitude == rhs.postLatitude && lhs.postLongitude == rhs.postLongitude
}

然后就是：

let filteredNewArrayOfUserPosts = newArrayOfUserPosts.filter{!contains(userPosts, $0)}

Answer 3

将等于的添加到您的结构中。

struct Refinement: Equatable {
    let key: String
    var value: String
}

如果要添加自己的条件，请添加]​​>

func == (leftHandSide: Refinement, rightHandSide: Refinement) -> Bool {
    return (leftHandSide.key == rightHandSide.key) && (leftHandSide.value == rightHandSide.value)
}
否则，它将默认检查struct中的所有值。

然后按常规==

]检查数组>

if expectedFacetRefinements == facetRefinements {
    print("true")
} else {
    print("false")
}