对于嵌套数组上的Swift相等运算符感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍数组嵌套对象，并为您提供关于2.12Swift的一元、二元和三元运算符[Swift原创教程]、2.13Swif

对于嵌套数组上的Swift相等运算符感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍数组嵌套对象，并为您提供关于2.12 Swift的一元、二元和三元运算符 [Swift原创教程]、2.13 Swift的位运算符和防溢出运算符 [Swift原创教程]、2.14 比较运算符和区间运算符 [Swift原创教程]、8.8 Swift恒等运算符的有用信息。

• 嵌套数组上的Swift相等运算符（数组嵌套对象）
• 2.12 Swift的一元、二元和三元运算符 [Swift原创教程]
• 2.13 Swift的位运算符和防溢出运算符 [Swift原创教程]
• 2.14 比较运算符和区间运算符 [Swift原创教程]
• 8.8 Swift恒等运算符

嵌套数组上的Swift相等运算符（数组嵌套对象）

为什么最后一个语句无法编译为错误：Binary operator ''=='' cannot be applied to two ''[[Simple]]’operands，并且有一种方法可以修改Simple结构或扩展==运算符以对嵌套数组（或字典）执行相等性检查？

var i1: [Int] = [1]var i2: [Int] = [1]i1 == i2 // -> truevar i3: [[Int]] = [[1], [2]]var i4: [[Int]] = [[1], [2]]i3 == i4 // -> truestruct Simple: Equatable, Hashable {    let message: String    var hashValue: Int {        return message.hashValue    }}func ==(lhs: Simple, rhs: Simple) -> Bool {    return lhs.message == rhs.message}var a: [Simple] = [Simple(message: "a")]var b: [Simple] = [Simple(message: "a")]a == b // -> truevar x: [[Simple]] = [[Simple(message: "a")], [Simple(message: "b")]]var y: [[Simple]] = [[Simple(message: "a")], [Simple(message: "b")]]x == y // -> ERROR! Binary operator ''=='' cannot be applied to two ''[[Simple]]’ operands

答案1

更新： 条件一致性已在 Swift 4.1中 实现 。 特别是：

现在，标准库类型Optional，Array和Dictionary的元素类型符合Equatable时，它们便符合Equatable协议。…

（来自Swift
CHANGELOG）。

现在可以任意嵌套Equatable元素数组，Equatable并且可以与进行比较==。您的密码

var x: [[Simple]] = [[Simple(message: "a")], [Simple(message: "b")]]var y: [[Simple]] = [[Simple(message: "a")], [Simple(message: "b")]]x == y

如果Simple为，则在Xcode 9.3中编译Equatable。

（旧答案：）
其原因与为什么未为可选数组定义Equatable相似。如果元素类型为，则可以 与 数组进行 比较
：==``Equatable

/// Returns true if these arrays contain the same elements.public func ==<Element : Equatable>(lhs: [Element], rhs: [Element]) -> Bool

这就是为什么

var a: [Simple] = [Simple(message: "a")]var b: [Simple] = [Simple(message: "a")]a == b // -> true

编译。

但即使是equatable类型T，Array<T> 不符合
该Equatable协议，比较为什么我不能做阵列符合Equatable？。因此，在

var x: [[Simple]] = [[Simple(message: "a")], [Simple(message: "b")]]var y: [[Simple]] = [[Simple(message: "a")], [Simple(message: "b")]]x == y // -> ERROR! Binary operator ''=='' cannot be applied to two ''[[Simple]]’ operands

x和y与元素类型阵列[Simple]，其不会 不 符合Equatable协议，并且不存在匹配的==运算符。

您可以==为简单的嵌套数组定义通用运算符，如下所示：

func ==<Element : Equatable> (lhs: [[Element]], rhs: [[Element]]) -> Bool {    return lhs.count == rhs.count && !zip(lhs, rhs).contains {$0 != $1 }}

或更简单（如@kennytm所建议）：

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

这样可以进行x == y编译并按预期工作。目前，似乎没有办法==在任意嵌套的数组上定义运算符。

2.12 Swift的一元、二元和三元运算符 [Swift原创教程]

2.13 Swift的位运算符和防溢出运算符 [Swift原创教程]

2.14 比较运算符和区间运算符 [Swift原创教程]

8.8 Swift恒等运算符

/**

恒等运算符

*/

class Rect {

// 结构体成员变量

var width: Double = 5.0

var height: Double = 6.0

// 结构体的成员方法,可以访问使用成员属性。

func getWidth() -> Double {

return width

}

func show() -> Void {

print("width\(width)")

}

}

var rect1: Rect = Rect()

var rect2: Rect = rect1

print("---------------->")

print("rect1.width==\(rect1.width)")

print("rect1.height==\(rect1.height)")

// 改变rect1 的宽度

rect1.width = 100.0

print("rect2.width==\(rect2.width)")

print("rect2.height==\(rect2.height)")

/**

我们可以看到

rect1 赋给 rect2 后，改变 rect1的宽度，那么 rect2的宽度也改变了。

说明是让rect2指向rect1。 也就是它们两个指向同一个实例。

说明类是引用类型

*/

/**

类的实例出现这种赋值操作的时候，比如将rect1 赋给 rect2，

这个是引用，不会拷贝一块新的内存；

rect2 rect1 实际上指向同一个实例，称之为同一个实例的两个引用。

那么如果有多个变量或常量指向同一个类的实例的时候，那么我们怎么

判断这多个常量 变量是否指向同一个实例呢？

如何判断 rect2 rect1 指向同一个实例呢？

Swift提供了一个恒等于 运算符

*/

/**

关系运算符 == !=

判断两个对象是否指向同一个类的实例的。

===

!==

*/

if rect1 === rect2 {

print("equal")

}

if rect1 !== rect2 {

print("Not equal")

}

/**

特别注意的是，

只能用于类的实例

不能用于结构体

*/

关于嵌套数组上的Swift相等运算符和数组嵌套对象的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于2.12 Swift的一元、二元和三元运算符 [Swift原创教程]、2.13 Swift的位运算符和防溢出运算符 [Swift原创教程]、2.14 比较运算符和区间运算符 [Swift原创教程]、8.8 Swift恒等运算符等相关知识的信息别忘了在本站进行查找喔。