假设我们在Swift中有一个非常大的struct：
struct SuperStruct {
var field1: Int = 0
var field2: String = ""
// lots of lines...
var field512: Float = 0.0
}
..然后我们需要实现Equatable协议：
extension SuperStruct: Equatable {
}
func ==(lhs: SuperStruct, rhs: SuperStruct) -> Bool {
return
lhs.field1 == rhs.field1 &&
lhs.field2 == rhs.field2 &&
// lots of lines...
lhs.field512 == rhs.field512
}
...我们需要编写许多愚蠢的代码行。 有没有办法＆＃34;要问＆＃34;编译器＆＃34;做＆＃34;它对我们来说？
答案 0 :(得分：4)
以下答案显示了一个可能的解决方案;可能不是推荐的（但可能对此问题的未来读者感兴趣）。
如果你有大量的属性都属于有限数量的不同类型，你可以使用Mirror个结构实例并迭代结构'性能;每次尝试转换为您知道属性的不同类型。
在观看了以下WWDC 2015会议之后，我编辑了之前的答案（对于我认为非常整洁的东西）（感谢Leo Dabus！）：
我将在这个答案的底部留下最初的答案，因为它显示了一种替代的，不那么面向协议的方法，以利用这个Mirror解决方案。
Mirror＆amp;面向协议的解决方案：
/* Let a heterogeneous protocol act as "pseudo-generic" type
for the different (property) types in 'SuperStruct' */
protocol MyGenericType {
func isEqualTo(other: MyGenericType) -> Bool
}
extension MyGenericType where Self : Equatable {
func isEqualTo(other: MyGenericType) -> Bool {
if let o = other as? Self { return self == o }
return false
}
}
/* Extend types that appear in 'SuperStruct' to MyGenericType */
extension Int : MyGenericType {}
extension String : MyGenericType {}
extension Float : MyGenericType {}
// ...
/* Finally, 'SuperStruct' conformance to Equatable */
func ==(lhs: SuperStruct, rhs: SuperStruct) -> Bool {
let mLhs = Mirror(reflecting: lhs).children.filter { $0.label != nil }
let mRhs = Mirror(reflecting: rhs).children.filter { $0.label != nil }
for i in 0..<mLhs.count {
guard let valLhs = mLhs[i].value as? MyGenericType, valRhs = mRhs[i].value as? MyGenericType else {
print("Invalid: Properties 'lhs.\(mLhs[i].label!)' and/or 'rhs.\(mRhs[i].label!)' are not of 'MyGenericType' types.")
return false
}
if !valLhs.isEqualTo(valRhs) {
return false
}
}
return true
}
使用示例：
/* Example */
var a = SuperStruct()
var b = SuperStruct()
a == b // true
a.field1 = 2
a == b // false
b.field1 = 2
b.field2 = "Foo"
a.field2 = "Foo"
a == b // true
上一个Mirror解决方案：
/* 'SuperStruct' conformance to Equatable */
func ==(lhs: SuperStruct, rhs: SuperStruct) -> Bool {
let mLhs = Mirror(reflecting: lhs).children.filter { $0.label != nil }
let mRhs = Mirror(reflecting: rhs).children.filter { $0.label != nil }
for i in 0..<mLhs.count {
switch mLhs[i].value {
case let valLhs as Int:
guard let valRhs = mRhs[i].value as? Int where valRhs == valLhs else {
return false
}
case let valLhs as String:
guard let valRhs = mRhs[i].value as? String where valRhs == valLhs else {
return false
}
case let valLhs as Float:
guard let valRhs = mRhs[i].value as? Float where valRhs == valLhs else {
return false
}
/* ... extend with one case for each type
that appear in 'SuperStruct' */
case _ : return false
}
}
return true
}
使用示例：
/* Example */
var a = SuperStruct()
var b = SuperStruct()
a == b // true
a.field1 = 2
a == b // false
b.field1 = 2
b.field2 = "Foo"
a.field2 = "Foo"
a == b // true
答案 1 :(得分：1)
不，它没有。至少不是以任何方式过于复杂并且基于运行时内省的使用（滥用？）。有关技术上有用的内容，请参阅dfri's answer，但方式比编写直接比较所有字段的==实现更复杂。
至于您对Swift中“应该”可用内容的看法，如果您与with Apple或Swift open source community共享，则更有可能看到效果。
答案 2 :(得分：1)
您可以使struct Codable并比较JSON编码的数据。效率不高，但对某些应用程序（例如单元测试）可能有用。
struct SuperStruct: Encodable {
var field1: Int = 0
// ....
var field512: Float = 0.0
}
let s1 = SuperStruct()
let s2 = SuperStruct()
let encoder = JSONEncoder()
let data1 = try! encoder.encode(s1)
let data2 = try! encoder.encode(s2)
let result = (data1 == data2)
如果你喜欢这个，你可以把它整理成Encodable的协议扩展名。
答案 3 :(得分：1)
在Swift 4.1中，如果所有类型的成员都是Equatable / Hashable
，则Equatable / Hashable类型现在可以合成Equatable / Hashable的一致性开发人员必须编写大量的样板代码来支持复杂类型的兼容性和可靠性。此提议为编译器提供了一种方法，可以自动合成Equatable和Hashable的一致性，以减少此样板，在已知可生成正确实现的方案的子集中。
https://github.com/apple/swift-evolution/blob/master/proposals/0185-synthesize-equatable-hashable.md