Swift：元组、typealias和泛型

一、元组

元组是多个值组合而成的复合值。元组中的值可以是任意类型，而且每一个元素的类型可以是不同的。

1. 直接给元组填充内容

let http404Error = (404,"Not Found")

2. 给元组内容设置名称

let http200Status = (statusCode: 200,description: "OK")

3. 访问元组

let code = http200Status.0
let code2 = http200Status.statusCode
let desc = http200Status.1
let desc2 = http200Status.description

元组使用举例：

1. 交换两个变量的值

传统的交换两个变量值的方式是定义临时变量来实现

func exchange(inout num1: Int,inout num2: Int){  
    var temp = num1;  
    num1 = num2;  
    num2 = temp;  
}  
  
var a = 10  
var b = 20  
exchange(&a,&b) 

有了元组后，我们可以这样写（帅呆了~~~）：

func swapMe<T>(inout a: T,inout b: T) {
    (a,b) = (b,a)
}

2. 同时返回结果与错误信息

在objective-c中，经常有请求网络数据的需求，所以我们会自定义一个block用来返回数据和异常。有了元组之后就方便多了。如下面的例子：

func doSomethingMightCauseError() -> (Bool,NSError?) {
    //.... a > 5 是模拟条件
    let a = 3
    if a > 5 {
        return (true,nil)
    } else {
        return (false,NSError(domain: "Some Error",code: 1,userInfo: nil))
    }
}

let (success,maybeError) = doSomethingMightCauseError()
if let error = maybeError {
    // do something
} else {

}

可以看出，调用的时候，直接将结果返回为元组，处理起来就非常方便了。

二、typealias

其实typealias就相当于objective-c中的typedef,就是将类型重命名，看起来更加语义化。

例如，计算两点之间的距离。普通写法：

func distanceBetweenPoint(point: CGPoint,toPoint: CGPoint) -> Double {
    let dx = Double(toPoint.x - point.x)
    let dy = Double(toPoint.y - point.y)
    return sqrt(dx * dx + dy * dy)
}
let origin: CGPoint = CGPoint(x: 0,y: 0)
let point: CGPoint = CGPoint(x: 1,y: 1)
let distance: Double = distanceBetweenPoint(origin,point)

代码中变量类型都是CGPoint和Double，不能清晰的表达业务需求。所以，我们可以通过typealias进行改造。

typealias Location = CGPoint
typealias distance = Double
func distanceBetweenPoint2(location: Location,toLocation: Location) -> distance {
    let dx = distance(location.x - toLocation.x)
    let dy = distance(location.y - toLocation.y)
    return sqrt(dx * dx + dy * dy)
}
let origin2: Location = Location(x: 0,y: 0)
let point2: Location = Location(x: 1,y: 1)
let distance2: distance = distanceBetweenPoint2(origin,point)

此时，看上去，Location就是坐标点，distance就是距离。

三、泛型

泛型就是在定义方法、类等的时候不指定具体的类型，只是用一个字符或者字符串进行占位工作，等到真正调用方法或者类等的时候，传递进来具体的类型。泛型能够很好地实现代码的重构，减少重复代码。

1. 交换两个变量的值：

在上面的例子中，交换的两个变量的类型是确定的，都是Int，但如果此时要交换的是String类型，感觉代码又必须重写一份了，而且重写的部分就是将代码中的Int替换为String。所以，此时我们可以考虑使用泛型了。先看看写法。

func swapValue<T>(inout first: T,inout second: T) {
    let temp = first
    first = second
    second = temp
}

var number1: Int = 20
var number2: Int = 30
swapValue(&number1,&number2)

在定义函数swapValue的时候，传递了泛型T，此时并不知道T具体是什么类型，在调用的时候，指定具体类型即可。这样，不管是交换什么类型变量的值就都可以了。

2. 查询数组中某个值的索引

func findindex<T: Equatable>(array: [T],valuetoFind: T) -> Int? {
    for (index,value) in enumerate(array) {
        if value == valuetoFind {
            return index
        }
    }
    return nil
}

let array = [3,6,13,7,4,90,34]
let index = findindex(array,13)

泛型数据比较，必须实现Equatable协议。

3. 模拟栈

struct Stack<T> {
    var items = [T]()
    mutating func push(item: T) {
        items.append(item)
    }
    mutating func pop() -> T {
        return items.removeLast()
    }
}

var stackOfString = Stack<String>()
stackOfString.push("Jack")
stackOfString.push("Rose")
stackOfString.push("Ruby")
let fromTop = stackOfString.pop()