Swift Explore

在我们进行 App 开发的时候，经常会用到的一个操作就是判断两个对象是否相等。比如两个字符串是否相等。而所谓的 相等 有着两层含义。一个是值相等，还有一个是引用相等。如果熟悉 Objective-C 开发的话，就会知道 Objective-C 为我们提供了一系列 isEqual: 方法来判断值相等，而 == 等于号用来判断引用相等。 我们来看一个 Objective-C 的例子就会更加明白了：

NSArray *arr1 = @[@"cat",@"hat",@"app"];
NSArray *arr2 = @[@"cat",@"hat",@"app"];

NSLog(@"result %i", (arr1 == arr2));                // result 0
NSLog(@"result %i", [arr1 isEqualToArray:arr2]);    // result 1

上面的代码中，我们定义了两个数组，arr1 和 arr2 这两个数组中保存的是同样的元素。接下来我们对他们进行相等比较并输出结果。第一次我们用 == 等于号进行比较，返回的结果是 0， 也就是说比较失败了。原因相信有些经验的同学都应该明白，是因为 在 Objective-C 中 == 比较的是引用，因为 arr1 和 arr2 是两个不同的对象，所以即便他们的值相同，但他们的引用也不相同。所以 == 比较会失败。而第二个比较用得是 NSArray 的 isEqualToArray 方法，这个方法是用来进行值比较的，因为这两个数组的值相同，所以 isEqualToArray 的比较方法会返回 1。

<!-- more -->

Equatable 协议

我们通过 Objective-C 了解了相等操作的运作机制，包含了值相等和引用相等。现在我们回到 Swift 中来。相信有 Objective-C 经验的同学一定会在找 isEqual 方法，但会发现 Swift 的原生类中没有 isEqual 的定义。

如果想对 isEqual 进行更深入的了解，这篇文章 Equality 里面有详细的讲解。我们这里不过多叙述。

Swift 中没有提供 iEqual 方法的定义，而是用另一种更加自然的方式，重载操作符 来处理相等判断的。重载 == 操作符是通过 Equatable 协议来完成的。我们通过实现这个协议中的方法来实现操作符的重载。

func ==(lhs: Self, rhs: Self) -> Bool

Swift 中自己实现了数组类，叫做 Array, 关于 Array 类型，这篇文章有详细的叙述 Swift Tips - Array 类型。Swift 中的 Array 类型实现了 Equatable 协议，所以我们可以对 Array 类型的实例通过 == 操作符进行比较：

var arr1 = ["cat","hat","app"]
var arr2 = ["cat","hat","app"]
println arr1 == arr2        // true

我们看到，在 Swift 中直接使用 == 进行比较的效果和 Objective-C 中的 isEqual: 方法的实际效果是一样的。他们都对值进行比较。Swift 的这点特性和 Objective-C 略有不同。Swift 的原生类中，几乎都实现了 Equatable 协议。

实现 Equatable 协议

我们现在了解了 Swift 中的 Equatable 协议。相信细心的同学已经发现了，我们在 Swift 中之所以可以对实例用 == 进行比较，是因为这个符号操作的对象实现了 Equatable 协议。那如果对没实现这个协议的对象使用 == 进行比较呢？我们可以看一下这段代码：

上面的代码中，我们定义了一个 Name 类，并实例化了这个类的两个对象 john 和 copy。然后我们用 == 对这两个进行比较，这时编译器报错了。原因就是我们这个类没有实现 Equatable 协议。

那么下面我们对这个类进行一下修改：

class Name :Equatable {

    var firstName:String?
    var lastName:String?

    init(firstName first:String, lastName last:String){

        self.firstName = first
        self.lastName = last

    }

}
func ==(lhs: Name, rhs: Name) -> Bool {

    return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName

}

在我们的修改中，我们实现了 Equatable 协议，并实现了 func ==(lhs: Name, rhs: Name) -> Bool 方法。判断只有在 firstName 和 lastName 都相等的情况下，这两个 Name 对象才算相等。

进行完这个修改后，我们就可以继续使用我们之前的判断了：

if john == copy {

    print("equal")  //equal

}

这次，if 语句中的 print 方法被成功的执行了。

现在我们知道了 Swift 中的大部分类都有自己对 == 操作符的实现。那么如果我们现在想比较两个对象的引用是否相等该怎么办呢？

我们可以使用 ObjectIdentifier 类来取得对象的引用标识，我们明确的调用这个类的构造方法来取得对象的引用，并进行比较：

if ObjectIdentifier(john) == ObjectIdentifier(copy) {
  print("equal")
}else{
  print("not equal")    // not equal
}

我们用 ObjectIdentifier 取得了对象的引用地址，并且 ObjectIdentifier 本身又实现了 Equatable 协议，所以 我们对转换后的 ObjectIdentifier 对象用 == 进行比较，就可以判断应用是否相同了。

Comparable

我们刚才介绍了 Equatable 协议，和它相关的还有一个 Comparable 协议。 Equatable 协议是对相等性进行比较。而 Comparable 是对顺序进行比较。比如 Swift 中的 Double 类，就实现了 Comparable 协议：

var left:Double = 30.23
var right:Double = 50.55

if left < right {

  print("30.23 is less than 50.55")

}

实现了 Comparable 协议的类，就可以使用 >,<,<=,>= 这些操作符进行比较了。这个协议的定义如下：

protocol Comparable { ... }

func <=(lhs: Self, rhs: Self) -> Bool

func >=(lhs: Self, rhs: Self) -> Bool

func >(lhs: Self, rhs: Self) -> Bool

你是不是会觉得，要实现比较操作，我们要实现这里面所有的方法呢。我们不妨花几分钟时间仔细的看一看这个协议的定义，并且思考一下。

  1. 首先，顺序比较的操作符有四个，<=,>=,>,< 大家可以看一下这个协议，好像是不是少了 < 的定义呢？
  2. 然后，我们再分析一下这些操作符的逻辑关系，>=, 实际上是 > 和 == 的一个并列关系，如果我们实现了这两个操作符，实际上 >= 的逻辑也就明确了。这个 >= 的操作符的逻辑一般就是这个语句： return lhs > rhs || lhs == rhs。

通过上面简短的分析，我们是不是发现了一个规律？ 其实就是，我们只要实现某几个操作符，就能推出其他操作符的逻辑。举个例子，以上面的 Comparable 接口的定义来看，<= 和 > 这两个操作符，我们只需要实现其中一个就可以推导出另外一个。比如，我们实现了 > 操作符，那么 '<=' 操作符只需要的前面那个函数取反即可。

那么，我们 <= 函数的实现，只需要类似这样实现即可：

func <=(lhs: Self, rhs: Self) -> Bool {

  return !(lhs > rhs)

}

仔细想一想，其实我们只要实现 == 和 < 操作符，其他的几个操作符都能够通过这两个推导出来了：

  1. >= 可以通过 < 的逻辑取反和 == 一起的逻辑或操作推导出。
  2. > 可以通过 < 的逻辑取反推导出。
  3. <= 可以通过 < 和 == 的逻辑或操作推导出。

关于这方面的知识，有一个概念叫做 严格全序,有兴趣的同学可以读一读。

那么现在问题又来了，我们其实只要实现 == 和 < 方法的逻辑就可以完成比较操作了，那么对其他操作符的实现代码，其实都是一样的。就显得有些冗余了。

而 Swift 正为我们解决了这个问题，为我们提供了协议的默认实现，仔细查看 Swift 文档的话，我们会发现除了 Comparable 协议，还定义了一个 _Comparable 协议，而前者继承自后者。 _Comparable 协议的定义如下：

protocol _Comparable { ... }
func <(lhs: Self, rhs: Self) -> Bool

我们发现，刚刚我们丢失的 < 在这里找到了。 _Comparable 就是 Swift 中提供的默认协议实现机制的例子。_Comparable 协议中提供了对其他几个操作符 >=,>,<= 的默认实现。

由于 Comparable 同时继承自 _Comparable 和 Equatable 协议，所以我们只需要实现 < 和 == 这两个操作符，即可完成整个比较操作的实现。下面我们来看一个例子：

class Name: Comparable {

  var firstName:String
  var lastName:String

  init(firstName first:String,lastName last:String){

    self.firstName = first
    self.lastName = last

  }
}

func ==(lhs: Name, rhs: Name) -> Bool {

  return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName
}

func <(lhs: Name, rhs: Name) -> Bool {

  return lhs.firstName < rhs.firstName && lhs.lastName < rhs.lastName

}

let john = Name(firstName: "John", lastName: "Smith")
let johnClone = Name(firstName: "John", lastName: "Smith")
let jack = Name(firstName: "Jack", lastName: "Smith")
let mary = Name(firstName: "Mary", lastName: "Williams")

print(john >= jack)         //true
print(john <= jack)         //true
print(john == jack)         //false
print(john > jack)          //false
print(john < jack)          //false
print(jack < mary)          //true
print(john == johnClone)    //true

var names:Array<Name> = [johnClone,mary,john,jack]
//[{firstName "John" lastName "Smith"}, {firstName "Mary" lastName "Williams"}, {firstName "John" lastName "Smith"}, {firstName "Jack" lastName "Smith"}]
names.sort { (lhs, rhs) -> Bool in
  return lhs > rhs
}

//[{firstName "Mary" lastName "Williams"}, {firstName "John" lastName "Smith"}, {firstName "John" lastName "Smith"}, {firstName "Jack" lastName "Smith"}]

我们在这里完整的实现了 Comparable 协议，我们定义了一个 Name 类，并实现了 < 和 == 协议方法，其中一个来自 _Comparable 协议，一个来自 Equatable 协议。而 Comparable 协议中的三个比较方法，已经在 _Comparable 中提供了默认的实现，所以我们就不用再自己实现一遍了。（注意两个 Comparable 和 _Comparable 的下划线区别，这是两个不同的协议。）

Hashable

最后一个要提到的还有 Hashable 协议。我们对 Dictionary 的概念应该不陌生，那么如果一个对象想作为 Dictionary 的 key 的话，那么就需要实现 Hashable 协议。

Swift 中以下这些类默认实现了 Hashable 协议：

  • Double
  • Float, Float80
  • Int, Int8, Int16, Int32, Int64
  • UInt, UInt8, UInt16, UInt32, UInt64
  • String
  • UnicodeScalar
  • ObjectIdentifier

所以这些类的实例，可以作为 Dictionary 的 key。 我们来看一下 Hashable 协议的定义：

protocol Hashable { ... }

var hashValue: Int { get }

定义非常简单，我们只需要实现 hashValue 定义 hash 值的计算方法即可。关于 hash 值的优化方法我们就又是另外一个课题了，所以我们这里只做简单讨论，将用类的属性的 hash 值再次进行异或操作计算新的 hash 值即可。还是以我们的 Name 类为例：


class Name: Comparable,Hashable {

  ...

  var hashValue: Int {
    return self.firstName.hashValue ^ self.lastName.hashValue
  }

}

接下来我们就将它作为字典的 key 了：

let john = Name(firstName: "John", lastName: "Smith")
let johnClone = Name(firstName: "John", lastName: "Smith")
let jack = Name(firstName: "Jack", lastName: "Smith")
let mary = Name(firstName: "Mary", lastName: "Williams")

var nameMap:[Name: String] = [:]
nameMap[john] = "Manager"
nameMap[jack] = "Stuff"

这片文章介绍了 Swift 中的三个协议 Equatable,Comparable,Hashable, 虽然我们平时不会太注意这几个协议，但在我们的开发工作中，他们却无时无刻不再起着作用，我们的 if 语句，排序操作，字典和数组的操作，都和这几个协议相关。 而 Swift 中的大部分类，基本都实现了这几个协议。可以说虽然我们经常遗忘他们，但它们又无时无刻不在我们左右。了解他们之后，一定会对我们大有帮助。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Free-Thinker/p/5305062.html