Question

我想比较两个数组的元素并检查它们是否相等。我已经尝试了各种解决方案但没有任何效果。

我尝试了解决方案 How to compare two array of objects?

这是我的目标：

struct AccountBalance: Decodable {
    let balance: Double
    let currency: String

    init(balance: Double, currency: String ) {
        self.currency = currency
        self.balance = balance
    }

    enum CodingKeys: String, CodingKey {
        case currency = "Currency"
        case balance = "Balance"
    }
}

这是我尝试的链接中的代码：

let result = zip(accountBalance, getsSaved).enumerate().filter() {
                $1.0 == $1.1
                }.map{$0.0}

但是我收到了这个错误：

Closure tuple parameter '(offset: Int, element: (AccountBalance, AccountBalance))' does not support destructuring with implicit parameters

Answer 1

Array提供了一个函数elementsEqual，它能够比较两个数组而不明确地符合Equatable：

let result = accountBalance.elementsEqual(getsSaved) {
    $0.balance == $1.balance && $0.currency == $1.currency
}

修改

如果您希望等于结果而不管数组中对象的顺序，那么您只需为每个数组添加排序。

let result = accountBalance.sorted { $0.balance < $1.balance }.elementsEqual(getsSaved.sorted { $0.balance < $1.balance }) { $0.balance == $1.balance && $0.currency == $1.currency }

Answer 2

我猜两个数组在包含相同元素时应该被认为是相等的，无论是否排序。

首先，实施Equatable和Hashable。

我使用hashValue作为id，所以我可以先对数组进行排序。

以下是您的AccountBalance课程的样子：

struct AccountBalance: Decodable, Equatable, Hashable {


   // Important parts!
    var hashValue: Int{
        return balance.hashValue ^ currency.hashValue &* 1677619
    }
    static func == (lhs: AccountBalance, rhs: AccountBalance)  -> Bool{
        return lhs.balance == rhs.balance && lhs.currency == rhs.currency
    }

}

然后创建一个算法，对ararys进行排序，然后逐个检查每个元素是否内容相同。

以下是使用Equatable和Hashable。

的功能

func isEqual(arr1: [AccountBalance], arr2: [AccountBalance]) -> Bool{

    if arr1.count != arr1.count{
        return false
    }

    let a = arr1.sorted(){
        $0.hashValue > $1.hashValue
    }

    let b = arr2.sorted(){
        $0.hashValue > $1.hashValue
    }

    let result = zip(a, b).enumerated().filter() {
        $1.0 == $1.1
        }.count

    if result == a.count{
        return true
    }

    return false
}

Answer 3

我不确定你的其余代码是做什么的，但是让参数显式化会让XCode感到高兴：

let result = zip(accountBalance, getsSaved).enumerated().filter() { (arg) -> Bool in
    let (_, (balance1, balance2)) = arg     
    return balance1.balance == balance2.balance
}.map{ $0.0 }`

直接尝试(_, (balance1, balance2)) -> Bool in，但它不会让我

Answer 4

我建议您实现您提供的链接的已接受答案，因为它控制两个数组的大小相同并且命令它们。

但如果你想让你的代码有效，我就这样解决了：

为了控制比较，你的结构应该实现Equatable协议并重载operator ==

extension AccountBalance : Equatable {}

func ==(lhs: AccountBalance, rhs: AccountBalance) -> Bool {
    return lhs.balance == rhs.balance && lhs.currency == rhs.currency
}

然后比较两个数组并检查是否包含false，如果是，则表示数组中的一个或多个项目不相同。

let result = !zip(accountBalance, getsSaved).enumerated().map() {
    $1.0 == $1.1
}.contains(false)

希望它可以帮到你

Answer 5

具有多个数组的样本：

import Foundation

let arr1: [String?] = ["word", nil, "word3", "word4"]
let arr2: [Double?] = [1.01, 1.02, nil, 1.04]
let arr3: [Int?] = [nil, 2, 3, 4]

var tuple1: [(title: String, number: String, coord: String)] = []

let countArray = arr1.count

for element in 0..<countArray {
    tuple1.append((arr1[element].map 
{String($0)} ?? "", arr2[element].map 
{String($0)} ?? "", arr3[element].map 
{String($0)} ?? ""))
}

print(tuple1)

打印结果：

[(title: "word1", number: "1.01", coord: ""), (title: "", number: "1.02", coord: "2"), (title: "word3", number: "", coord: "3"), (title: "word4", number: "1.04", coord: "4")]

如何比较两个数组的元素

5 个答案: