Swift学习第五枪

梦里梦外; 2022-07-24 09:21 153阅读 0赞

# 方法（methods）和下表脚本（Subscripts） #

*  实例方法(Instance Methods)
 *  类型方法(Type Methods)
 *  下表脚本（Subscripts）

--------------------

方法是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与 Objecti  
ve-C 中的类方法（class methods）相似。

--------------------

结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。

# 1.实例方法 (Instance Methods) #

实例方法是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致.

实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。

下面的例子，定义一个很简单的 Counter 类， Counter 能被用来对一个动作发生的次数进行计数：

class Counter {
    
    var count = 0//可变属性 count
    
    func increment() {//让计数器按一递增
    ++count
    }
    
    func incrementBy(amount: Int) {//让计数器按一个指定的整数值递增
    count += amount
    }
    
    func reset() {//将计数器重置为0
    count = 0
    }
    
    }

Counter 类定义了三个实例方法： - increment 让计数器按一递增； - incrementBy(amount: Int) 让计数器按一个指定的整数值递增； - reset 将计数器重置为0。Counter 这个类还声明了一个可变属性 count ，用它来保持对当前计数器值的追踪。和调用属性一样，用点语法（dot syntax）调用实例方法：

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

# 1.1方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods) #

函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用）。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关了）。

Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如： with ， for ， by 等等。前面的 Counter 类的例子中 incrementBy(\_:) 方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。

具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称；默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。

看看下面这个 Counter 的另一个版本（它定义了一个更复杂的 incrementBy(\_:) 方法）：

class Counter {
    
    var count: Int = 0
    
    func incrementBy(amount: Int, numberOfTimes: Int) {
    count += amount * numberOfTimes
    }
    
    }

incrementBy(\_:numverOfTimes:) 方法有两个参数： amount 和 numberOfTimes 。默认情况下，Swift 只把amount 当作一个局部名称，但是把 numberOfTimes 即看作局部名称又看作外部名称。下面调用这个方法：

let counter = Counter()
    counter.incrementBy(5, numberOfTimes: 3)
    // counter 的值现在是 15

你不必为第一个参数值再定义一个外部变量名：因为从函数名 incrementBy(\_numberOfTimes:) 已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。 这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。

# 1.2修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods) #

有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（ \# ）作为第一个参数的前缀来把这个局部名称当作外部名称使用。相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（ \_ ）作为该参数的显式外部名称，这样做将覆盖默认行为。

# 1.3 self 属性(The self Property) #

类型的每一个实例都有一个隐含属性叫做 self ， self 完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的 self 属性来引用当前实例。

上面例子中的 increment 方法还可以这样写：

func increment() {
    self.count++
    }

实际上，你不必在你的代码里面经常写 self 。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写 self ，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的 Counter 中已经示范了： Counter 中的三个实例方法中都使用的是 count （而不是 self.count ）。

使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用 self 属性来区分参数名称和属性名称。

下面的例子中， self 消除方法参数 x 和实例属性 x 之间的歧义：

struct Point {
    var x = 0.0, y = 0.0
    func isToTheRightOfX(x: Double) -> Bool {
    return self.x > x
    }
    }
    let somePoint = Point(x: 4.0, y: 5.0)
    if somePoint.isToTheRightOfX(1.0) {
    print("This point is to the right of the line where x == 1.0")
    }
    // 打印输出: This point is to the right of the line where x == 1.0

如果不使用 self 前缀，Swift 就认为两次使用的 x 都指的是名称为 x 的函数参数。

# 1.4在实例方法中修改值类型(Modifying Value Types from Within Instance Methods) #

结构体和枚举是 值类型。一般情况下，值类型的属性不能在它的实例方法中被修改。但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择 变异(mutating) 这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的 self 属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。

要使用 变异 方法， 将关键字 mutating 放到方法的 func 关键字之前就可以了：

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
    x += deltaX
    y += deltaY
    }
    }
    var somePoint = Point(x: 1.0, y: 1.0)
    somePoint.moveByX(2.0, y: 3.0)
    print("The point is now at (\(somePoint.x), \(somePoint.y))")
    // 打印输出: "The point is now at (3.0, 4.0)"

上面的 Point 结构体定义了一个变异方法（mutating method） moveByX(\_:y:) 用来移动点。 moveByX 方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上 mutating 关键字，这才让方法可以修改值类型的属性。

注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见存储属性和实例变量：

let fixedPoint = Point(x: 3.0, y: 3.0)
    fixedPoint.moveByX(2.0, y: 3.0)
    // 这里将会抛出一个错误

# 1.5 在变异方法中给self赋值(Assigning to self Within a Mutating Method) #

变异方法能够赋给隐含属性 self 一个全新的实例。上面 Point 的例子可以用下面的方式改写：

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
    self = Point(x: x + deltaX, y: y + deltaY)
    }
    }

新版的变异方法 moveByX(\_:y:) 创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。

枚举的变异方法可以把 self 设置为相同的枚举类型中不同的成员：

enum TriStateSwitch {
    case Off, Low, High
    mutating func next() {
    switch self {
    case Off:
    self = Low
    case Low:
    self = High
    case High:
    self = Off
    }
    }
    }
    var ovenLight = TriStateSwitch.Low
    ovenLight.next()
    // ovenLight 现在等于 .High
    ovenLight.next()
    // ovenLight 现在等于 .Off

上面的例子中定义了一个三态开关的枚举。每次调用 next 方法时，开关在不同的电源状态（ Off ， Low ， High ）之前循环切换。

# 2 类型方法 (Type Methods) #

实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做 类型方法。声明结构体和枚举的类型方法，在方法的 func 关键字之前加上关键字 static 。类可能会用关键字 class 来允许子类重写父类的实现方法。

注意：  
在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。

类型方法和实例方法一样用点语法调用。但是，你是在类型层面上调用这个方法，而不是在实例层面上调用。下面是如何在 SomeClass 类上调用类型方法的例子：

class SomeClass {
    class func someTypeMethod() {
    // type method implementation goes here
    }
    }
    SomeClass.someTypeMethod()

在类型方法的方法体（body）中， self 指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用 self 来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。

一般来说，任何未限定的方法和属性名称，将会来自于本类中另外的类型级别的方法和属性。一个类型方法可以调用本类中另一个类型方法的名称，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。  
下面的例子定义了一个名为 LevelTracker 结构体。它监测玩家的游戏发展情况（游戏的不同层次或阶段）。这是一个单人游戏，但也可以存储多个玩家在同一设备上的游戏信息。  
游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。 LevelTracker 结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。

struct LevelTracker {
    static var highestUnlockedLevel = 1
    static func unlockLevel(level: Int) {
    if level > highestUnlockedLevel { highestUnlockedLevel = level }
    }
    static func levelIsUnlocked(level: Int) -> Bool {
    return level <= highestUnlockedLevel
    }
    var currentLevel = 1
    mutating func advanceToLevel(level: Int) -> Bool {
    if LevelTracker.levelIsUnlocked(level) {
    currentLevel = level
    return true
    } else {
    return false
    }
    }
    }

LevelTracker 监测玩家的已解锁的最高等级。这个值被存储在静态属性 highestUnlockedLevel 中。  
LevelTracker 还定义了两个类型方法与 highestUnlockedLevel 配合工作。第一个类型方法是 unlockLevel ：一旦新等级被解锁，它会更新 highestUnlockedLevel 的值。第二个类型方法是 levelIsUnlocked ：如果某个给定的等级已经被解锁，它将返回 true 。（注意：尽管我们没有使用类似 LevelTracker.highestUnlockedLevel 的写法，这个类型方法还是能够访问静态属性 highestUnlockedLevel ）

除了静态属性和类型方法， LevelTracker 还监测每个玩家的进度。它用实例属性 currentLevel 来监测玩家当前的等级。  
为了便于管理 currentLevel 属性， LevelTracker 定义了实例方法 advanceToLevel 。这个方法会在更新 currentLevel 之前检查所请求的新等级是否已经解锁。 advanceToLevel 方法返回布尔值以指示是否能够设置 currentLevel 。

下面， Player 类使用 LevelTracker 来监测和更新每个玩家的发展进度：

class Player {
    var tracker = LevelTracker()
    let playerName: String
    func completedLevel(level: Int) {
    LevelTracker.unlockLevel(level + 1)
    tracker.advanceToLevel(level + 1)
    }
    init(name: String) {
    playerName = name
    }
    }

Player 类创建一个新的 LevelTracker 实例来监测这个用户的进度。它提供了completedLevel 方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了 advanceToLevel 返回的布尔值，因为之前调用LevelTracker.unlockLevel 时就知道了这个等级已经被解锁了）。你还可以为一个新的玩家创建一个 Player 的实例，然后看这个玩家完成等级一时发生了什么：

var player = Player(name: "Argyrios")
    player.completedLevel(1)
    print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
    // 打印输出：highest unlocked level is now 2

如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：

player = Player(name: "Beto")
    if player.tracker.advanceToLevel(6) {
    print("player is now on level 6")
    } else {
    print("level 6 has not yet been unlocked")
    }
    // 打印输出：level 6 has not yet been unlocked

# 3 下标脚本（Subscripts） #

内容：

1.  下标脚本语法
2.  下标脚本用法
3.  下标脚本选项

下标脚本 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问集合（collection），列表（list）或序列（sequence的快捷方式，使用下标脚本的索引设置和获取值，不需要再调用实例的特定的赋值和访问方法。举例来说，用下标脚本访问一个数组(Array)实例中的元素可以这样写 someArray\[index\] ，访问字典(Dictionary)实例中的元素可以这样写 someDictionary\[key\] 。

对于同一个目标可以定义多个下标脚本，通过索引值类型的不同来进行重载，下标脚本不限于单个纬度，你可以定义多个入参的下标脚本满足自定义类型的需求。

# 3.1 下标脚本语法 #

下标脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和计算型属性的混合。与定义实例方法类似，定义下标脚本使用 subscript 关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是下标脚本可以设定为读写或只读。这种方式又有点像计算型属性的getter和setter：

subscript(index: Int) -> Int {
    get {
    // 返回与入参匹配的Int类型的值
    }
    set(newValue) {
    // 执行赋值操作
    }
    }

newValue 的类型必须和下标脚本定义的返回类型相同。与计算型属性相同的是set的入参声明 newValue 就算不写，在set代码块中依然可以使用默认的 newValue 这个变量来访问新赋的值。  
与只读计算型属性一样，可以直接将原本应该写在 get 代码块中的代码写在 subscript 中：

subscript(index: Int) -> Int {
    // 返回与入参匹配的Int类型的值
    }

下面代码演示了一个在 TimesTable 结构体中使用只读下标脚本的用法，该结构体用来展示传入整数的 n 倍。

struct TimesTable {
    let multiplier: Int
    subscript(index: Int) -> Int {
    return multiplier * index
    }
    }
    let threeTimesTable = TimesTable(multiplier: 3)
    print("3的6倍是\(threeTimesTable[6])")
    // 输出 "3的6倍是18"

在上例中，通过 TimesTable 结构体创建了一个用来表示索引值三倍的实例。数值 3 作为结构体 构造函数 入参初始化实例成员 multiplier 。你可以通过下标脚本来得到结果，比如threeTimesTable\[6\] 。这条语句访问threeTimesTable 的第六个元素，返回 6 的 3 倍即18 。

**注意：**  
TimesTable 例子是基于一个固定的数学公式。它并不适合对 threeTimesTable\[someIndex\] 进行赋值操作，这也是为什么附属脚本只定义为只读的原因。

# 3.2下标脚本用法 #

根据使用场景不同下标脚本也具有不同的含义。通常下标脚本是用来访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。你可以在你自己特定的类或结构体中自由的实现下标脚本来提供合适的功能。

例如，Swift 的字典（Dictionary）实现了通过下标脚本来对其实例中存放的值进行存取操作。在下标脚本中使用  
和字典索引相同类型的值，并且把一个字典值类型的值赋值给这个下标脚本来为字典设值：

var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
    numberOfLegs["bird"] = 2

上例定义一个名为 numberOfLegs 的变量并用一个字典字面量初始化出了包含三对键值的字典实例。 numberOfLegs 的字典存放值类型推断为 \[String:Int\] 。字典实例创建完成之后通过下标脚本的方式将整型值 2 赋值到字典实例的索引为 bird 的位置中。

注意：

Swift 中字典的附属脚本实现中，在 get 部分返回值是 Int? ，上例中的 numberOfLegs 字典通过附属脚本返  
回的是一个 Int? 或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是 nil ；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为 nil 即可。

# 3.3下标脚本选项 #

下标脚本允许任意数量的入参索引，并且每个入参类型也没有限制。下标脚本的返回值也可以是任何类型。下标脚本可以使用变量参数和可变参数，但使用写入读出（in-out）参数或给参数设置默认值都是不允许的。

一个类或结构体可以根据自身需要提供多个下标脚本实现，在定义下标脚本时通过入参个类型进行区分，使用下标脚本时会自动匹配合适的下标脚本实现运行，这就是 下标脚本的重载 。

一个下标脚本入参是最常见的情况，但只要有合适的场景也可以定义多个下标脚本入参。如下例定义了一个 Matrix 结构体，将呈现一个 Double 类型的二维矩阵。 Matrix 结构体的下标脚本需要两个整型参数：

struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]
    init(rows: Int, columns: Int) {
    self.rows = rows
    self.columns = columns
    grid = Array(count: rows * columns, repeatedValue: 0.0)
    }
    func indexIsValidForRow(row: Int, column: Int) -> Bool {
    return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> Double {
    get {
    assert(indexIsValidForRow(row, column: column), "Index out of range")
    return grid[(row * columns) + column]
    }
    set {
    assert(indexIsValidForRow(row, column: column), "Index out of range")
    grid[(row * columns) + column] = newValue
    }
    }
    }

Matrix 提供了一个两个入参的构造方法，入参分别是 rows 和 columns ，创建了一个足够容纳 rows \* columns 个数的 Double 类型数组。通过传入数组长度和初始值0.0到数组的一个构造器，将 Matrix 中每个元素初始值0.0。关于数组的构造方法和析构方法请参考创建一个空数组 。

你可以通过传入合适的 row 和 column 的数量来构造一个新的 Matrix 实例：

var matrix = Matrix(rows: 2, columns: 2)

上例中创建了一个新的两行两列的 Matrix 实例。在阅读顺序从左上到右下的 Matrix 实例中的数组实例 grid 是矩阵二维数组的扁平化存储：

// 示意图
    grid = [0.0, 0.0, 0.0, 0.0]
    col0 col1
    row0 [0.0, 0.0,
    row1 0.0, 0.0]

将值赋给带有 row 和 column 下标脚本的 matrix 实例表达式可以完成赋值操作，下标脚本入参使用逗号分割

matrix[0, 1] = 1.5
    matrix[1, 0] = 3.2

上面两条语句分别 让matrix 的右上值为 1.5，坐下值为 3.2：

[0.0, 1.5,
    3.2, 0.0]

Matrix 下标脚本的 getter 和 setter 中同时调用了下标脚本入参的 row 和 column 是否有效的判断。为了方便进行断言， Matrix 包含了一个名为 indexIsValidForRow(\_:column:) 的成员方法，用来确认入参的 row 或 column 值是否会造成数组越界：

func indexIsValidForRow(row: Int, column: Int) -> Bool {
    return row >= 0 && row < rows && column >= 0 && column < columns