Baylee的技术博客

性能指标：面向用户的各种属性。

在考虑优化应用性能时通常从以下方面入手：

1. 内存

   • 内存涉及运行应用所需的RAM最小值，以及应用消耗的内存平均值和峰值。最小内存值会严重限制硬件，而更高的内存平均值和峰值意味着更多的后台应用会被强制关闭。
   • 确保没有内存泄漏。随时间持续增长的内存消耗可能会因为内存不足的异常而崩溃。

2. 电量消耗

   考虑执行时间和CPU资源的利用（高效的数据结构和算法 + 高效地使用硬件）。

3. 初始化时间

   惰性初始化是个好方法，但也不能让用户总是在执行后续任务时等待。

   阅读全文 »

扩展就是为一个已有的类、结构体、枚举类型或协议类型添加新功能，包括逆向建模（在没有权限获取原始源代码的情况下扩展类型）。和OC不同的是，Swift中的扩展没有名字。

Swift中的扩展可以实现的功能：

• 添加计算型属性和计算型类型属性
• 定义实例方法和类型方法
• 提供新的构造器（只能添加便利构造器）
• 定义下标
• 定义和使用新的嵌套类型
• 使一个已有类型符合某个协议
  阅读全文 »

在泛型的参数列表中通过where子句可以为关联类型定义约束。where子句后跟一个或多个针对关联类型的约束，以及一个或多个类型参数和关联类型之间的相等关系。

下面的例子定义了一个名为 allItemsMatch 的泛型函数，用来检查两个 Container 实例是否包含相同顺序的相同元素。如果所有的元素能够匹配，那么返回 true，否则返回 false。

被检查的两个 Container 可以不是相同类型的容器（虽然它们可以相同），但它们必须拥有相同类型的元素。这个要求通过一个类型约束以及一个 where 子句来表示：

泛型就是适用于任意类型、灵活可重用的函数及类型。泛型可以避免代码的重复。比如Swift的数组、字典、可选类型。

泛型数据结构

比如自定义一个名stack（栈）函数：

1
2
3
4
5
6
7
8
9

struct IntStack{
    var items = [Int]()
    mutating func push(_ item: Int){
        items.append(item)
    }
    mutating func pop()->Int{
        return items.removeLast()
    }
}

这个结构体在栈中使用一个名为 items 的 Array 属性来存储值。Stack 提供了两个方法：push(_:) 和 pop()，用来向栈中压入值以及从栈中移除值。这些方法被标记为 mutating，因为它们需要修改结构体的 items 数组。

这个IntStack结构体只适用于Int类型。下面把这个结构体改成适合任意类型的泛型：

1
2
3
4
5
6
7
8
9

struct Stack<Element>{
    var items = [Element]()
    mutating func push(_ item: Element){
        item.append(item)
    }
    mutating func pop() -> Element{
        return items.removeLast()
    }
}

Element 为待提供的类型定义了一个占位名。这种待提供的类型可以在结构体的定义中通过 Element 来引用。

1
2
3
4

var stackStrings = Stack<String>()
stackStrings.push("name")
stackStrings.push("age")
let fromtheTop = stackStrings.pop()

泛型函数和方法

比如实现一个交换函数：

1
2
3
4
5
6
7
8
9

func swapTwoInts(_ a: inout Int, _ b: inout Int){
    let temp = a
    a = b
    b = temp
}

var someInt = 3
var anotherInt = 5
swapTwoInts(&someInt, &anotherInt)

把上面的函数改写成泛型函数：

1
2
3
4
5

func swapTwoValues<T>(_ a: inout T, _ b: inout T){
    let temp = a
    a = b
    b = temp
}

这个泛型函数使用了占位类型名（在这里用字母 T 来表示）来代替实际类型名（例如 Int、String 或 Double）。占位类型名没有指明 T 必须是什么类型，只有 swapTwoValues(_:_:) 函数在调用时，才能根据所传入的实际类型决定 T 所代表的类型。T也被称为类型参数。

另外一个不同之处在于这个泛型函数名（swapTwoValues(_:_:)）后面跟着占位类型名（T），并用尖括号括起来（<T>）。这个尖括号告诉 Swift 那个 T 是 swapTwoValues(_:_:) 函数定义内的一个占位类型名，因此 Swift 不会去查找名为 T 的实际类型。

如果泛型函数需要多个类型参数，将他们都写在尖括号中，用逗号分开。

类型约束

虽然泛型类型和泛型函数可以作用于任何类型，但有时需要给泛型类型或泛型函数中的类型添加一个特定的类型约束。类型约束可以指定一个类型参数必须继承自指定类，或者符合一个特定的协议或协议组合。

Swift 的 Dictionary 类型对字典的键的类型做了些限制。在字典的描述中，字典的键的类型必须是可哈希（hashable）的。也就是说，必须有一种方法能够唯一地表示它。Dictionary 的键之所以要是可哈希的，是为了便于检查字典是否已经包含某个特定键的值。若没有这个要求，Dictionary 将无法判断是否可以插入或者替换某个指定键的值，也不能查找到已经存储在字典中的指定键的值。

一个类型约束被强制加到 Dictionary 的键类型上，要求其键类型必须符合 Hashable 协议，这是 Swift 标准库中定义的一个特定协议。所有的 Swift 基本类型（例如 String、Int、Double 和 Bool）默认都是可哈希的。

类型的约束语法

语法示例：

1
2
3

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // 泛型函数的函数体部分
}

第一个类型参数 T，有一个要求 T 必须是 SomeClass 子类的类型约束；第二个类型参数 U，有一个要求 U 必须符合 SomeProtocol 协议的类型约束。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//普通函数
func findIndex(ofString valueToFind: String, in array: [String]) ->Int?{
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

//泛型函数
func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) ->Int?{
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

上面的T之所以需要遵守Equatable协议的原因：

在相等性检查上，即 “if value == valueToFind“。不是所有的 Swift 类型都可以用等式符（==）进行比较。比如说，如果你创建一个自定义的类或结构体来表示一个复杂的数据模型，那么 Swift 无法猜到对于这个类或结构体而言“相等”意味着什么。正因如此，这部分代码无法保证适用于每个可能的类型 T，当你试图编译这部分代码时会出现相应的错误。

Swift 标准库中定义了一个 Equatable 协议，该协议要求任何遵循该协议的类型必须实现等式符（==）及不等符(!=)，从而能对该类型的任意两个值进行比较。所有的 Swift 标准类型自动支持 Equatable 协议。

关联类型协议

协议不能是泛型，但是协议支持类型的一个相关特性：关联类型。

关联类型为协议中的某个类型提供了一个占位名，它代表的实际类型在协议被采纳时才会被指定。使用associatedtype关键字来指定关联类型。

1
2
3
4
5
6

protocol Container{
    associatedtype ItemType
    mutating func append(_ item: ItemType)
    var count: Int{ get }
    subscript(i: Int) -> ItemType{ get }
}

Container 协议需要在不知道容器中元素的具体类型的情况下引用这种类型。Container 协议声明了一个关联类型 ItemType，写作 associatedtype ItemType。ItemType 是什么类型的别名由遵循该协议的类型来提供。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

struct Stack<Element>: Container {
    // Stack<Element> 的原始实现部分
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    // Container 协议的实现部分
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

通过扩展一个存在的类型来指定关联类型

形式：

1

extension Array: Container{}

定义了这个扩展后，你可以将任意 Array 当作 Container 来使用。

可能发生的错误分为两大类：可恢复的错误和不可恢复的错误。

常见的可恢复错误：

• 试图打开不存在的文件
• 试图和下线的服务器通信
• 试图在设备没有网络连接时通信

常见的不可恢复错误：

• 强制展开值为nil的可空实例
• 数组越界

说明：Swift中的错误处理涉及到错误处理模式，这会用到Cocoa和OC中NSError。

协议本身并未实现任何功能，但协议可以像其他类型一样当做一个类型来使用。使用场景：

• 作为函数、方法或构造器中的参数类型或返回值类型
• 作为常量、变量或属性的类型
• 作为数组、字典或其他容器中的元素类型
  阅读全文 »

协议规定了实现某些功能的方法、属性。类、结构体或枚举都可以遵循协议，并提供协议的具体实现。

语法

定义方式：

1
2
3

protocal SomeProtocol{
    //协议的属性、方法等
}

自定义类型遵循某个协议：

1
2
3

struct SomeStructure: FirstProtocol, AnotherProtocol{
    //结构体定义部分
}

拥有父类的类在遵循协议：

在一些支持iOS6、iOS7的项目中，转换statusBarStyle的方法：

方法一

1. info.plist文件中添加：View controller-based status bar appearance为NO；

2. 在viewController中实现：

   阅读全文 »

在Swift中不仅类可以定义实例方法和类型方法，结构体和枚举类型也可以定义实例方法和类型方法。这是Swift和Objective-C之间的只要区别之一。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
    func increment(by amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}

let counter = Counter()
// 初始计数值是0
counter.increment()
// 计数值现在是1
counter.increment(by: 5)
// 计数值现在是6
counter.reset()
// 计数值现在是0

上面的increment方法还可以写成：

1. 析构器只适用于类类型。
2. 当一个类的实例被释放时，析构器会被立即调用。
3. 会被自动调用，但不能主动调用。类似于OC的dealloc。
4. 子类继承了父类的析构器，子类析构器的最后，父类的析构器会被自动调用。
5. 每个类最多只能有一个析构器，而且不带任何参数。
6. 析构器可以访问实例的所有属性，并可以修改它的行为。
   阅读全文 »