泛型

Swift泛型(generics) 让我们写出的类型和函数可以使用对于我们或编译器都未知的类型。 很多内建类型(包括可空类型、数组和字典)都是用泛型实现的，比如数组和一些集合就是用泛型方式来实现的。

一种运行时进行类型检查的技术，效率高但是不安全。在swift中泛型可用于结构体、类以及函数和方法

定义可空类型的泛型变量

let x: Optional<Int> = 3

print(x) //~~ 3

上述代码实际上用到了系统提供的协议，具体的在后续详细讲解，这里只了解其用法就可以了

enum Optional<Wrapped> {
    case None
    case Some(Wrapped)
}

定义泛型类型

语法：class/struct Name<Type>，上述尖括号中的Type是一个占位符，也可换成其它名称，比如T，在实例化时会换成实际的值。

比如一个简单的堆栈实现

//Element是一个占位符，也可换成其它名称
struct Stack<T>: Sequence { 
    var items = [T]()

    mutating func push(_ newItem: T) {
        items.append(newItem)
    }
    
     mutating func pop() -> T? {
        guard !items.isEmpty else {
            return nil
        }
        return items.removeLast()
    }
}

//~~~使用，在代码运行时，泛型T会换成Int
var stack = Stack<Int>()    

定义泛型函数和方法

函数和类的方法的返回值和参数也可以用泛型来代码，比如下拉代码声明了一个泛型函数。

    func myMap<T,U> ( _ items:[T], _ f:(T)->(U) )  -> [U]{
        var result = [U]()
        for item in items{
            result.append( f(item) )
        }
        return result
    }

方法测试

let string = ["one", "two", "three"]
let stringLen = myMap(string){$0.count} //第一个cod为一个函数
print(stringLen) //~~ [3,3,5]

给泛型占位符设置约束条件

泛型的比较，必须要把泛型标识符声明为系统提供的Equatable类型。

func checkIfEqual<T: Equatable>(_ first: T, _ second: T) -> Bool {
    return first == second
}
print(checkIfEqual(1, 1)) //~~true
print(checkIfEqual("a string", "a string")) //~~true
print(checkIfEqual("a string", "a different string")) //~~false

多个约束符的例子，下例表示用CustomStringConvertible保证了first和second都有返回字符串的属性description。

func checkIfDescriptionsMatch<T: CustomStringConvertible, U: CustomStringConvertible>(
        _ first: T, _ second: U) -> Bool {
    return first.description == second.description
}

print(checkIfDescriptionsMatch(Int(1), UInt(1)))
print(checkIfDescriptionsMatch(1, 1.0))
print(checkIfDescriptionsMatch(Float(1.0), Double(1.0)))

泛型与协议

协议是不可以直接使用泛型的，如果想在协议中使用泛型，可以使用一个叫“关联类型”的特性。用到关键字 associatedtype来修饰协议属性，比如系统提供的IteratorProtocol协议就是如下定义的：

protocol IteratorProtocol {
    associatedtype Element 
    mutating func next() -> Element?
}

上述associatedtype Element表示符合这个协议的类型必须提供具体类型做为Element类型。符合这个协议的类型应该在其定义为内部为Element提供typealias定义，那么就可以按如下方式使用了：

//用 StackIterator 把Stack封装起来。
struct StackIterator<T>: IteratorProtocol {
    typealias Element = T
    
    var stack: Stack<T>
    
    mutating func next() -> Element? {
        return stack.pop()
    }
}

这段代码可以借助Swift类型推断功能，简写为如下形式：

struct StackIterator<T>: IteratorProtocol {
    var stack: Stack<T>

    mutating func next() -> T? {
        return stack.pop()
    }
}

使用

var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
var myStackIterator = StackIterator(stack: myStack)
while let value = myStackIterator.next() {
    print("got \(value)")
}

where子语句

用占位类型s把pushAll(_：)变成泛型方法，它是符合Sequence协议的类型。S的约束保证我们可以用for-in语法循环遍历之。不过，这还不够。为了把从sequence中取出的数据项推入栈，需要确保从序列类型中来的数据项类型和栈元素的类型匹配。也就是说，还需要一个约束让S所产生元素的类型是Element。

    //where语句相当于一个过滤器
    mutating func pushAll<S: Sequence>(_ sequence: S) 
                                       where S.Iterator.Element == Element {
        for item in sequence {
            self.push(item)
        }
    }

附：Stack 示例实现

struct Stack<Element>: Sequence {
    var items = [Element]()

    mutating func push(_ newItem: Element) {
        items.append(newItem)
    }

    mutating func pop() -> Element? {
        guard !items.isEmpty else {
            return nil
        }
        return items.removeLast()
    }

    func map<U>(_ f: (Element) -> U) -> Stack<U> {
        var mappedItems = [U]()
        for item in items {
            mappedItems.append(f(item))
        }
        return Stack<U>(items: mappedItems)
    }

    // Sequence 协议的方法
    func makeIterator() -> StackIterator<Element> {
        return StackIterator(stack: self)
    }

    mutating func pushAll<S: Sequence>(_ sequence: S) where S.Iterator.Element == Element {
        for item in sequence {
            self.push(item)
        }
    }
}

类型操作

值的比较

类型的比较在很多场景下都有需求，在Swift中可通过实现Equatable和Comparable这两个协议来实现。

实现Equatable协议

struct Point: Equatable {
    let x: Int
    let y: Int
    static func == (lhs: Point, rhs: Point) -> Bool {
        return (lhs.x == rhs.x) && (lhs.y == rhs.y)
    }
}
let a = Point(x: 3, y: 4)
let b = Point(x: 3, y: 4)
let abEqual = (a == b) //~~ true
let noAbEqual = (a != b) //~~ false

上述代码中==（中缀运算符）被声明为了static方法，事实上==是定义在全局范围内的。

实现Comparable协议

Comparable会提供更多的功能，因为Comparable继承了Equatable。

//自定义的Point结构体实现Comparable
struct Point: Comparable { //因为继承的原因，所以这块不需要写成Equatable,Comparable 
    let x: Int
    let y: Int
    
    static func ==(lhs: Point, rhs: Point) -> Bool {
        return (lhs.x == rhs.x) && (lhs.y == rhs.y)
    }
    
    static func <(lhs: Point, rhs: Point) -> Bool {
        return (lhs.x < rhs.x) && (lhs.y < rhs.y)
    }
}

let a = Point(x: 3, y: 4)
let b = Point(x: 3, y: 4)

let abEqual = (a == b) //true
let abNotEqual = (a != b) //false

let c = Point(x: 2, y: 6) //false
let d = Point(x: 3, y: 7) //false

let cdEqual = (c == b) //false
let cLessThanD = (c < d) //true

let cLessThanEqualD = (c <= d) //true
let cGreaterThanD = (c > d) //false
let cGreaterThanEqualD = (c >= d) //false

自定义运算符

Swift允许开发者创建自定义运算符。这个特性意味着我们可以创建自己的运算符来表示两个Person的实例结婚了。自定义运算符不太建议使用，因为它也只限于数学运算范围内，正常情况下使用系统提供的就够了。

定义自定义类

class Person: Equatable {
    var name: String
    var age: Int
    weak var spouse: Person?
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    func marry(_ spouse: Person) {
        self.spouse = spouse
        spouse.spouse = self
    }
}

添加自定义运算符

在Person类声明的外面添加以下代码，以添加自定义运算符。

//声明一个新运算符
infix operator +++
func +++(lhs: Person, rhs: Person) {
    lhs.spouse = rhs
    rhs.spouse = lhs
}

添加自定义运算符到默认组

precedencegroup Marriage {
    associativity: none  //这是一个运算优先级定义
}

如果没有上述代码，则因为swift内部对新添加的运算符默认添加到swift内部默认的组为DefaultPrecedence。

使用自定义运算符

let drew = Person(name: "Drew", age: 33)
let matt = Person(name: "Matt", age: 32)