Swift进阶

本文是对WWDC2014–AdvancedSwift的总结

改变参数名

比如我们要改变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以及Dictionary<K,V>:是范型的结构体
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)做个图示:
fibonacci(n:5)

在图中我们发现fib(1),fib(2)等函数被持续的调用,我们如果可以把这个已经计算过的数值存下来,那么以后不是就就可以直接计算了呢?这样不就可以极大的提高计算的速度。这样我们就只计算下面带星号的函数即可:
valuable func

这时最先想到的就是用一个全局的字典手动来存储这个数值,实现方法如下:

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操作时候,却得到了下面的错误提示:
for_in_error
这时候我们需要理解下,什么是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(),它是一个结构体,其遵守Generatorprotocol)。

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] )
  }
} 

这样就可以对Stackfor in操作了。

func peekStack(s: Stack<T>) {
  for x in s { println(x) }
} 

关于SequenceGenerator的详细说明,请看我的另外一篇博客Swift中Collection的Protocol

执行效率

Swift是静态编译,很小的runtime。写好的代码传到设备上之后不需要再重新编译,只需要等着运行即可。Swift中的编译器,相比于C,C++,Objective-C的Clang,做了一步优化:
SwiftComplier
除此之外,Swift会在编译时候做以下几点

  • 全局分析App
  • 使用Struct不会对Runtime的性能造成影响
  • Int,Float等很多标准库都是Struct的

Swift还有去虚拟化的特点,它可以让再运行期确定的事情放到了编译期,这样就会更快了,详细内容可以参考我的另外一篇博客为什么Swift比OC快