本人录制技术视频地址:https://edu.csdn.net/lecturer/1899 欢迎观看。
一、元组
元组是多个值组合而成的复合值。元组中的值可以是任意类型,而且每一个元素的类型可以是不同的。
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()