改变参数名
比如我们要改变Thing对象的参数名:
class Thing {
init(location: Thing?, name:String,
longDescription: String){ ... }
}
如果我们不想用默认的Thing.init(location:Beijing, name:"wall",longDescription:"An amazing city")
这种方式进行初始化,我们可以在参数前面添加label
的形式:
class Thing {
init(newLocation location: Thing?, newName name: String,
newLongDescription longDescription: String) { ... }
}
这样我们就可以使用Thing.init(newLocation:Beijing, newName:"wall",newLongDescription:"An amazing city")
这种参数来进行初始化。
匿名参数
比如下面的例子,我们不需要字典中的value,那么我们就只需要遍历其key
即可。
for (key,_) in dictionary {
print(\(key))
}
在这个例子中,我们使用下划线_
来进行你匿名操作,略过了我们不关心的value值,而只输出了key
的值。
在上面Thing
的例子中,如果我们要移除其参数名称,那么我们可以将label
变为下划线,这样我们在调用的时候就不必写参数名了。
class Thing {
init(_ location: Thing?, _ name: String,
_ longDescription: String) { ... }
}
这样我们就可以使用Thing.init(Beijing, "wall","An amazing city")
来初始化了。
Protocol
如果我们要给上面的Thing
对象添加一个方法performPull
来执行其是否可以被拉动的方法。
// The parser will call this. func performPull(object: Thing)
{ if /* object is pullable */ {
/* pull it */
}else{
/* complain */
}
}
这时我们可以添加一个Protocol:
protocol Pullable {
func pull()
}
class Boards: Thing, Pullable {
func pull() {
....
}
}
这样我们的Boards
类就遵守了Pullable
协议,当我们来检查某个对象是否遵守了某个协议时,我们可以这样做:
func performPull(object: Thing) {
if let pullableObject = object as Pullable { pullableObject.pull()
}else{
print("You are not sure how to print a \(object.name).")
}
}
对象转String
如果我们要打印某个对象,并且需要打印出其中的有效信息,那么我们要像OC中实现description
方法一样,来遵守CustomStringConvertible
协议并且实现其中的description
方法。
还有很多类似的方法
Protocol | 作用 |
---|---|
ExpressibleByStringLiteral | “abc” |
ExpressibleByArrayLiteral | [ a, b, c ] |
ExpressibleByDictionaryLiteral | [a: x, b: y] |
Sequence | for x in sequence |
CustomStringConvertible | “(convertible)” |
同样,如果我们要对某个对象使用下表,那么我们要subscript
。怎样对某个类使用下表呢?
泛型
比如以下三个方法,其参数的形式是一样的,但是其参数类型不同,我们想把它变成一个函数,这时候我们最常想到的做法就是使用Any
来表示任何类型的参数和任何类型的返回值。
// 之前的三个函数
func peek(interestingValue: String) {
println("[peek] \(interestingValue)")
}
func peek(interestingValue: Int) {
println("[peek] \(interestingValue)")
}
func peek(interestingValue: Float) {
println("[peek] \(interestingValue)")
}
// 变为一个函数
func peek(interestingValue: Any) {
println("[peek] \(interestingValue)")
}
但是这有个问题,在我们要调用返回值的某个方法时候编译器会报错,因为我们的返回值Any
并没有所调用的方法,也就是说我们需要一次强转,强转在代码层面是很难看的,也很麻烦,这时候我们就可以使用泛型来解决这个问题,如果我们使用了泛型,那么编译器会将输入的参数和输出的参数给我们推断出来,这样就不必强转了。并且当编译器可以推断出来是那种type的时候它会给我们做各种优化。
泛型在Swift中很常见,比如:
Array
Optional
我们也可以创建自己的泛型类
Type间的关系
比如我们要转换两个变量的值,我们可以调用下面的方法:
// Exchange the values of x and y
func swap<T>(inout x: T, inout y: T) {
let tmp = x
x = y
y = tmp
}
var studentCount = 42
var teacherCount = 7
swap(&studentCount, &teacherCount) // OK
var schoolName = “Homestead High School"
swap(&studentCount, &schoolName) // error: 'Int' is not identical to 'String'
有了这样的编译器提示,这样我们就可以保证了输入的两种类型是相同的,这样就会更加安全,代码也会少很多bug。
对泛型进行Protocol限制
我们可以给泛型加上限制,让它遵守某些协议,比如:
func indexOf<T>(sought: T, inArray array: T[]) -> Int? {
for i in 0..array.count {
if array[i] == sought { // error: could not find an overload for '==' that accepts the supplied arguments
return i
} }
return nil }
这是编译不通过的,因为编译器不知道我们的T
是否遵守了Equatable
协议,如果我们将其变为func indexOf<T:Equatable>(Sought: T, inArray array: T[]) -> Int?
就可以编译通过了。
实现Equatable协议
Enum,Class以及Struct都可以实现协议,比如我们有如下的Struct,实现Equatable协议如下:
struct Temperature : Equatable {
let value: Int = 0
}
func == (lhs: Temperature, rhs: Temperature) -> Bool {
return lhs.value == rhs.value
}
当我们实现了Equatable
,那么对于!=
这种操作,Swift在底层就会自动帮我们实现。
斐波那契数列的例子
什么是菲波那切数列?数列的前两个数相加等于后面的一个数。 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
我们创建一个菲波那切数列的函数:
func fibonacci(n: Int) -> Double {
return n < 2 ? Double(n) : fibonacci(n - 1) + fibonacci(n - 2)
}
这个函数的返回值仍然是一个函数,它是一个递归调用的函数,这个函数的效率极低。当你在Playground中实验的时候就会卡的不行。如果调用fibonacci(44)
估计要十几秒的时间。原因就是它需要一个调用一个树状结构,我们用fibonacci(5)
做个图示:
在图中我们发现fib(1),fib(2)等函数被持续的调用,我们如果可以把这个已经计算过的数值存下来,那么以后不是就就可以直接计算了呢?这样不就可以极大的提高计算的速度。这样我们就只计算下面带星号的函数即可:
这时最先想到的就是用一个全局的字典手动来存储这个数值,实现方法如下:
var fibonacciMemo = Dictionary<Int, Double>() // implementation detail
// Return the nth fibonacci number: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
func fibonacci(n: Int) -> Double {
if let result = fibonacciMemo[n] {
return result
}
let result = n < 2 ? Double(n) : fibonacci(n - 1) + fibonacci(n - 2)
fibonacciMemo[n] = result
return result
}
// 1.61803399...
let phi = fibonacci(45) / fibonacci(44) //0.1 seconds = 100x speedup
这样一来,我们之前计算fibonacci(44)
中十几秒的计算时间一下子缩短到了0.1秒,缩减了100倍。
如果这样做的话,我们以后每次用到这个方法就都需要写一个字典,每次把这个计算过程过一遍,并且更重要的是它不具备通用型,如果我要放进去字符串,那就不起作用了。下面我们写一个通用的函数来解决这种需要保留中间数值,并且不需要额外的全局变量fibonacciMemo
就可以解决问题的方法。先看一个不递归时候的函数:
func memoize<T: Hashable, U>(work: @escaping (T)->U) -> (T)->U {
var memo = Dictionary<T, U>()
return { x in
if let q = memo[x] { return q }
let r = work(x)
memo[x] = r
return r
}
}
然后再来一个可以递归的方法:
func memoize<T: Hashable, U>(work: @escaping ((T)->U, T) -> U) -> (T)->U {
var memo = Dictionary<T, U>()
func wrap(x: T)->U {
if let q = memo[x] { return q }
let r = work(wrap, x)
memo[x] = r
return r
}
return wrap
}
这两个函数包含了swift中的很多高级语法:
- 强大的编译器推断匹配,比如你调用:
let fibonacci = memoize {
(n: Int) in
String(n)
}
那么上面泛型中的T
就会被推断成Int
,而U
怎会被推断成String
。
- 尾随闭包,比如调用
let fibonacci = memoize {...}
的时候。 - 更通用,更安全,性能更高的泛型函数。
关于这个函数,有人专门写了一篇博客来说明:https://medium.com/@mvxlr/swift-memoize-walk-through-c5224a558194
泛型结构体的一个例子
struct StringStack {
mutating func push(x: String) {
items += x }
mutating func pop() -> String {
return items.removeLast()
}
var items: String[]
}
这里我们创建了一个字符串的栈,如果我们要变为泛型,则需要:
struct Stack<T> {
mutating func push(x: T) {
items += x }
mutating func pop() -> T {
return items.removeLast()
}
var items: T[]
}
这样我们就可以往里面放任何数据类型了:
var intStack = Stack<Int>()
intStack.push(42)
但是当我们需要对这个Stack做for in
操作时候,却得到了下面的错误提示:
这时候我们需要理解下,什么是Sequence
,当Swift给我们做for in
操作的时候在底层给我们做了什么?
// 我们代码
for x in someSequence {
...
}
// Swift翻译后的代码
var __g = someSequence.generate()
while let x = __g.next(){
...
}
从上面可以看到,首先我们的someSequence
需要关联一个generate
,并且这个generate
需要实现一个next
方法,这样我们就可以对这个结构体做for in
操作了。
我们先看这个generate()
,它是一个结构体,其遵守Generator
(protocol
)。
protocol Generator {
typealias Element
mutating func next() -> Element ?
}
然后我们创建一个遵守Generator
的结构体:
struct StackGenerator<T> : Generator {
typealias Element = T
mutating func next() -> T? {
if items.isEmpty { return nil }
let ret = items[0]
items = items[1..items.count]
return ret
}
var items: Slice<T>
}
那么什么是Sequence
呢?它也是一个protocol
protocol Sequence {
typealias GeneratorType : Generator
func generate() -> GeneratorType
}
它关联了一个Generator
,然后我们让新建的Stack
遵守这个Sequence
协议:
extension Stack : Sequence {
func generate() -> StackGenerator<T> {
return StackGenerator( items[0..itemCount] )
}
}
这样就可以对Stack
做for in
操作了。
func peekStack(s: Stack<T>) {
for x in s { println(x) }
}
关于Sequence
和Generator
的详细说明,请看我的另外一篇博客Swift中Collection的Protocol
执行效率
Swift是静态编译,很小的runtime。写好的代码传到设备上之后不需要再重新编译,只需要等着运行即可。Swift中的编译器,相比于C,C++,Objective-C的Clang,做了一步优化:
除此之外,Swift会在编译时候做以下几点
- 全局分析App
- 使用Struct不会对Runtime的性能造成影响
- Int,Float等很多标准库都是Struct的
Swift还有去虚拟化的特点,它可以让再运行期确定的事情放到了编译期,这样就会更快了,详细内容可以参考我的另外一篇博客为什么Swift比OC快