泛型

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

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

定义可空类型的泛型变量

let x: Optional<Int> = 3print(x) //~~ 3

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

enum Optional<Wrapped> {case Nonecase 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 = Tvar 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: Intlet y: Intstatic 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: Intlet y: Intstatic 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) //falselet c = Point(x: 2, y: 6) //false
let d = Point(x: 3, y: 7) //falselet cdEqual = (c == b) //false
let cLessThanD = (c < d) //truelet cLessThanEqualD = (c <= d) //true
let cGreaterThanD = (c > d) //false
let cGreaterThanEqualD = (c >= d) //false

自定义运算符

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

定义自定义类

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

添加自定义运算符

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

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

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

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

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

使用自定义运算符

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