Arrays 斯威夫特字符串词典'；s数组相等

我正在尝试创建一个字典，其中字符串作为键，字符串数组作为值。
然后我想检查这些字典中是否有两个是相等的，如下所示：

let dicOfStringStringAr1: [String : [String]] = ["key1" : ["val", "for key 1"]]
let dicOfStringStringAr2: [String : [String]] = ["key1" : ["val", "for key 1"]]
if dicOfStringStringAr1 == dicOfStringStringAr2 {
    print("Dictionary of String Array")
}

但我得到了这个错误：

错误：二进制运算符“==”不能应用于两个“[String:[String]]”操作数

但是，如果值是String而不是[String]，它就可以工作

let dicOfStringAr1: [String : String] = ["key1" : "val"]
let dicOfStringAr2: [String : String] = ["key1" : "val"]
if dicOfStringAr1 == dicOfStringAr2 {
    print("Dictionary of String Array")
}

我不明白这个问题。
有人可以解释问题所在

---

查看字典的默认==Swift函数后

@warn_unused_result
public func ==<Key : Equatable, Value : Equatable>(lhs: [Key : Value], rhs: [Key : Value]) -> Bool

@warn\u未使用的\u结果
public func==（lhs:[键：值]、rhs:[键：值]）->Bool

我意识到没有定义将值表示为数组，并且“泛型”值不能解析为集合。（不知道为什么）。
因此，我创建了一个==函数，该函数将具有[Key:[Value]]参数。现在代码开始工作了

@warn_unused_result
public func ==<Key : Equatable, Value : Equatable>(lhs: [Key : [Value]], rhs: [Key : [Value]]) -> Bool {
    var result = lhs.count == rhs.count
    for (k, v) in lhs {
        guard let arValue = rhs[k] where result == true else {
            result = false
            break
        }

        result = v == arValue
    }

    return result
}

@warn\u未使用的\u结果
公共函数==（lhs:[Key:[Value]]，rhs:[Key:[Value]]）->Bool{
var result=lhs.count==rhs.count
对于lhs中的（k，v）{
guard let arValue=rhs[k]，其中result==true else{
结果=错误
打破
}
结果=v==arValue
}
返回结果
}

---

有人能解释为什么Swift==实现中的值不能解析为单个项，即数组吗？

幸运的是，您可以通过将字典转换为NSDictionary并使用其方法

isEqualToDictionary

来检查这些字典是否相等。例如：

if NSDictionary(dictionary: dicOfStringStringAr1).isEqualToDictionary(dicOfStringStringAr2) {
    print("Dictionary of String Array")
}

---

这实际上是有道理的。正如您可以从类型

的

=

函数中看到的那样，它需要

值

来符合

均衡

。默认情况下，

Array

类型不符合

equalable

注意，这并不意味着不能使用

==

比较两个数组

[1, 2, 3] == ["a", "b", "c"] // false.

符合

相等的

意味着您可以使用

=

，但不能使用相反的内容

当然，您可以扩展

数组

类型以符合

equalable

extension Array: Equatable {}
// Implement the following method.
public func ==<T: CollectionType, U: CollectionType>(lhs: T, rhs: U) -> Bool {}

public func  ==<Key : Equatable, Value : CollectionType where Value.Generator.Element: Equatable>(lhs: [Key : Value], rhs: [Key : Value]) -> Bool {
    guard lhs.keys.elementsEqual(rhs.keys) else { return false }

    for (key, value) in lhs {
        if !value.elementsEqual(rhs[key]!) { return false }
    }

    return true
}

例如：

struct Number: Equatable {
    var x: Int
    var y: Int
}

func ==(lhs: Number, rhs: Number) -> Bool {
    return lhs.x == rhs.x && lhs.y == rhs.y
}

let dicOfStringStringAr1: [String : [Number]] = ["key1" : [Number(x: 1, y: 2), Number(x: 1, y: 2)]]
let dicOfStringStringAr2: [String : [Number]] = ["key1" : [Number(x: 1, y: 2), Number(x: 1, y: 2)]]
if dicOfStringStringAr1 == dicOfStringStringAr2 {
    print("Dictionary of String Array") // "Dictionary of String Array"
}

---

这是一个仅适用于对象的漫游，如果我有一个struct数组，这段代码将中断。我正在寻找一个更通用的解决方案。这将是在你的问题中提供的有用信息。谢谢，但我强调“有人对问题有一些了解”。我明确表示，我更感兴趣的是理解问题，而不是四处走走。我已经更新了这个问题。我希望它能消除歧义。我想我读过一些关于matt的文章，说这是因为它会自动桥接到

NSString

等。但如果你想确定，你可以深入他的评论或帖子，在那里他已经回答了几次。有趣的想法是，你将如何实现你的==函数，使其具有泛型和类型安全性。我尝试了

==

将函数的范围限制为只能与==比较的数组，但也必须具有

==

以符合协议。问题是，最后一个问题是使用，所以我总是会出错。我将在稍后发布另一个关于这个问题的问题，以探索以通用方式工作的可能性。如果你对此有想法，我会在完成后发表新的评论。谢谢，这并不像我希望的那样通用，但它的工作方式比我的解决方案更广泛。例如，我无法使用此字典

[String:[String:String]]

结构。再次感谢您，我在这个实现中遇到了一个问题，它使两个集合之间的相等变得不明确。。。