(二十五)[Swift]标准库中的protocol

1.以下是本文章所举实例的结构体代码

struct Rational{
    var numerator : Int = 0
    var denominator : Int = 1
}

2.CustomStringConvertible协议

//默认打印太复杂
print(Rational()) //Rational(numerator: 0, denominator: 1)

我们可以实现这个协议，打印出一个定制的字符串

extension Rational : CustomStringConvertible{
    var description: String {
        get{
            return "(\(self.numerator)/\(self.denominator))"
        }
    }
}

这个时候再打印就会为

print(Rational()) //(0/1)

3.Equatable协议

对于自定义对象，我们是无法进==比较的

var r1 = Rational()
var r2 = Rational()
//r1 == r2  //报错

如果想进行==比较，我们可以实现Equatable协议

extension Rational : Equatable{}
func ==(lhs: Rational, rhs: Rational) -> Bool{
    return lhs.numerator == rhs.numerator && lhs.denominator == rhs.denominator
}

这样我们就能进行比较了

r1 == r2 //true
r1 != r2 //false

4.Comparable协议

默认情况下，我们也无法对自定义对象进行比较

var r3 = Rational()
var r4 = Rational()
//r3 < r4  //报错

我们可以实现Comparable协议，而这个协议继承了Equatable协议

extension Rational : Comparable{}

func == (lhs: Rational, rhs: Rational) -> Bool{
    return lhs.numerator == rhs.numerator && lhs.denominator == rhs.denominator
}
 func <(lhs: Rational, rhs: Rational) -> Bool{
    return Double(lhs.numerator)/Double(lhs.denominator) < Double(rhs.numerator)/Double(rhs.denominator)
}

只要实现了 == 和 <方法就可以进行所有的比较

r3 == r4   //true
r3 < r4    //false
r3 > r4    //false
r3 <= r4   //true
r3 >= r4   //true

可以比较了之后就可以对其类型的集合进行相应的操作

var rationals = Array<Rational>()
for i in 1...10{
    var r = Rational(numerator: i,denominator: i+1)
    rationals.append(r)
}

rationals.maxElement() //(10/11)
rationals.minElement() //(1/2)
rationals.contains(Rational(numerator: 2,denominator: 3)) //true
rationals.startsWith([Rational(numerator: 1,denominator: 2)]) //true

5.BooleanType协议

默认情况下，自定义对象是无法像OC中一样 单独的作为条件判断

//if r1 { } //报错

如果我们想让对象本身有一个布尔值，则可以实现BooleanType协议

extension Rational : BooleanType{
    var boolValue : Bool {
        get{
            return self.numerator != 0
        }
    }
}

这样每个对象就有它自己的一个布尔值了

var r5 = Rational(numerator: 1,denominator: 2)
if r5 {
    print("hahaha")
}else{
    print("hehehe")
}
// 打印hahaha

6.Hashable

默认情况下，自定义对象无法加入set集合

var rationalSet = Set<Rational>()
//报错:Rational' does not conform to protocol 'Hashable'

我们可以实现Hashable协议

extension Rational : Hashable{
    var hashValue: Int{
        get{
            return String(self.numerator).hashValue ^ String(self.denominator).hashValue
        }
    }
}```
只有实现HashValue的协议才可以作为字典key以及创建与其对应的set集合

var rationalSet = Set<Rational>()
rationalSet.insert(Rational())
var rationalDic = Dictionary<Rational,Int>()
var r6 = Rational()
var r7 = Rational()
rationalDic[r6] = 6
rationalDic[r7] = 7
print(rationalSet) //[(0/1)]
print(rationalDic) //[(0/1): 7]