一、元组
元组是多个值组合而成的复合值。元组中的值可以是任意类型，而且每一个元素的类型可以是不同的。
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()
版权声明：本文为博主原创文章，未经博主允许不得转载。