码迷,mamicode.com
首页 > 编程语言 > 详细

Swift:元组、typealias和泛型

时间:2015-07-28 10:50:12      阅读:133      评论:0      收藏:0      [点我收藏+]

标签:switch   泛型   元组 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()

版权声明:本文为博主原创文章,未经博主允许不得转载。

Swift:元组、typealias和泛型

标签:switch   泛型   元组 typealias   

原文地址:http://blog.csdn.net/sinat_27706697/article/details/47100015

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!