小伙伴们，swift开源啦！

<Writing High-Performance Swift Code>中的信息会给我们的开发带来很多实用性的建议。

一、降低动态调度

1.动态调度

class A {
var aProperty: [Int]
func doSomething() { ... }
 dynamic doSomethingElse() { ... }
 }
class B : A {
override var aProperty {
get { ... }
set { ... }
}
override func doSomething() { ... }
}
func usingAnA(a: A) {
a.doSomething()
a.aProperty = ...
}

2.使用'final'时，声明并不需要被重写

final class C {
// No declarations in class 'C' can be overridden.
var array1: [Int]
func doSomething() { ... }
}

 class D {
final var array1 [Int] // 'array1' cannot be overridden by a computed property.
var array2: [Int]      // 'array2' *can* be overridden by a computed property.
}

func usingC(c: C) {
c.array1[i] = ... // Can directly access C.array without going through dynamic dispatch.
c.doSomething() = ... // Can directly call C.doSomething without going through virtual dispatch.
}

func usingD(d: D) {
d.array1[i] = ... // Can directly access D.array1 without going through dynamic dispatch.
d.array2[i] = ... // Will access D.array2 through dynamic dispatch.
}

3.使用'private'时，在本类之外其声明并不需要访问

private class E {
func doSomething() { ... }
}

>class F {
private var myPrivateVar : Int
}

>func usingE(e: E) {
e.doSomething() // There is no sub class in the file that declares this class.
// The compiler can remove virtual calls to doSomething()
// and directly call A’s doSomething method.
}

>func usingF(f: F) -> Int {
return f.myPrivateVar
}

二、高效使用容器类型

1.数组中使用值类型

// Don't use a class here.
struct PhonebookEntry {
var name : String
var number : [Int]
}
var a : [PhonebookEntry]

2.在不需要NSArray桥接时，使用ContiguousArray作为参考类型

class C { ... }var a: ContiguousArray= [C(...), C(...), ..., C(...)]

3.必要时，可以使用NSArray代替对象

var c: [Int] = [ ... ]
var d = c        // No copy will occur here.
d.append(2)      // A copy *does* occur here.

func append_one(a: [Int]) -> [Int] {
a.append(1)
return a
}
var a = [1, 2, 3]
a = append_one(a)

func append_one_in_place(inout a: [Int]) {
a.append(1)
}
var a = [1, 2, 3]
append_one_in_place(&a)

三、未检查操作

使用未经检查的整数运算时，就能判断不可能发生溢出

a : [Int]
b : [Int]
c : [Int]
// Precondition: for all a[i], b[i]: a[i] + b[i] does not overflow!
for i in 0 ... n {
c[i] = a[i] &+ b[i]
}

四、泛型

如例：

class MySwiftFunc{ ... }MySwiftFuncX     // Will emit code that works with Int...MySwiftFuncY               // ... as well as String.
class MyStack{
func push(element: T) { ... }
func pop() -> T { ... }
}

func myAlgorithm(a: [T], length: Int) { ... }
// The compiler can specialize code of MyStack[Int]
var stackOfInts: MyStack[Int]
// Use stack of ints.
for i in ... {
stack.push(...)
stack.pop(...)
}

var arrayOfInts: [Int]
// The compiler can emit a specialized version of 'myAlgorithm' targeted for
// [Int]' types.
myAlgorithm(arrayOfInts, arrayOfInts.length)

1.在同一个文件中它们可以被用于一些通用声明

2.允许编译器执行一些通用序列化

//Framework.swift:
protocol Pingable { func ping() -> Self }
protocol Playable { func play() }
extension Int : Pingable {  
        func ping() -> Int { return self + 1 }

class Game: Playable {  
var t : T  init (_ v : T) {t = v}  
func play() {    
        for _ in 0...100_000_000 { t = t.ping() } 
 }
}

func play_a_game(game : Playable ) {  
           // This check allows the optimizer to specialize the  
           // generic call 'play'  
      if let z = game as? Game{
            z.play()
      } else {
           game.play() }
     }
/// -------------- >8
// Application.swift:
play_a_game(Game(10))

五、Swift的较大值

 protocol P {}
struct Node : P {
var left, right : P?
}

>struct Tree {
var node : P?
init() { ... }
}

使用copy-on-write语义来处理较大值

struct tree : P {
var node : [P?]
init() {
node = [ thing ]
}
}

final class Ref{   
         var val : T  init(_ v : T) {val = v}
}
struct Box{    
        var ref : Refinit(_ x : T) { ref = Ref(x) }
        var value: T {
        get { return ref.val }
        set {
                if (!isUniquelyReferencedNonObjC(&ref)) {
                ref = Ref(newValue)
                return       }
        ref.val = newValue}
}
}

<The type Box can replace the array in the code sample above>

六、代码的安全

example：
final class Node {
var next: Node?
var data: Int
...
}

使用非引用，以避免引用计数'开支'

var Ref : Unmanaged= Unmanaged.passUnretained(Head)
while let Next = Ref.takeUnretainedValue().next {
...
Ref = Unmanaged.passUnretained(Next)
}

七、协议

标记的协议只能满足固定那个类的协议

protocol Pingable : class { func ping() -> Int }

注：以上是个人读取相关文档的理解，仅供大家学习使用。