类型

  7 分钟阅读  

Swift 一个重要的概念是类型。类型是 Swift 中实现面向对象编程（object-oriented programming）、面向协议编程（protocol-oriented programming）以及泛型编程（generic programming）的基础。

在 Swift 中，所有变量的类型要么属于：

  • class
  • struct
  • enum
  • protocol（一定条件下）

要么属于：

  • tuple
  • 函数

我们分别介绍上面的几种类型，在其中会讨论它们之间的联系与区别。

类 class

Swift 中的 class 与 C++ 类似。

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

成员函数、成员变量及其访问控制

Swift 中成员函数和成员变量的概念与 C++ 基本一致，一个类对象拥有独立的成员变量，成员函数可以访问所有的成员变量。

class 的访问控制通过在成员声明前加上修饰符实现，包括：

  • public：默认，外界可访问，可写
  • private：外界不可访问
  • private(set)（成员变量）：外界可访问，不可写

在类中通过 self 引用自身，如果不会产生歧义，可以省略 self。

在类中时常会用到一种特殊的变量：计算变量。计算变量相当于一个没有参数的函数，每次获取其值的时候都要通过调用这个函数来计算：

class Rectangle {
    var width: Double
    var height: Double

    var area: Double {
        return width * height
    }
    ...
}

let rectangle = Rectangle(...)
print(rectangle.area)

计算变量是只读的，而且不会占用储存空间。如果计算的时间复杂度超过 O(1)O(1)，那么应该使用普通的函数，而不是计算变量。

构造函数和析构函数

构造函数使用关键字 init 声明。由于 Swift 没有零值初始化，所有成员变量都要有初值，要么直接在变量后显式指出，要么在构造函数中设定。构造函数结束时，所有成员变量都要有初值，否则产生编译错误。

class A {
    var bar: Int
    var foo = "Hello"

    init(bar: Int) {
        self.bar = bar
    }
}
let a = A(bar: 1)

如果类的每个成员变量都有默认值，那么可以使用默认构造函数：

class B {
    var bar = 1
    var foo = "Hello"
}
let b = B()

析构函数使用关键字 deinit 声明，不过在一般的开发中很少用到：

deinit {
    ...
}

静态变量、静态方法

使用 static 定义静态变量和方法：

class A {
    static let shared = A()
    static func foo() {...}
}

let a = A.shared
A.foo()

类是引用类型

Swift 中的类是引用类型，传递引用而非副本，相当于指针。比如：

class Counter {
    var count = 0
}

let a = Counter()
let b = a   // b is a reference of a

b.count += 1
print(a.count)  // 1

Swift 中对类的实例的管理使用类似于智能指针的方法，当引用计数为 0 时，实例被销毁。另外，可以在 var 前加上 weak 声明不参与计数的 weak 变量。

继承

Swift 支持类的继承，但不支持多重继承。与 C++ 不同，Swift 的继承没有 private、protected 和 public 之分，所有继承都相当于 C++ 中的 public。

另外，Swift 中所有的函数都相当于 C++ 中的虚函数，在派生类中使用 override 即可重写基类的方法；使用 super 调用基类的方法：

class Base {
    func foo() {
        print("Base")
    }
}

class Derived: Base {
    override func foo() {
        super.foo() // prints "Base"
        print("Derived")
    }
}

let derived = Derived()
derived.foo() // "Base Derived"

使用 as 向下进行类型转换，使用 as? 向上进行动态类型转换，使用 as! 进行强制类型转换：

var a: Base = Derived()
let b = a as? Derived // 类型为 Optional<Derived>
// 或 if let b = a as? Derived {...}

let c = a as! Derived // 类型为 Derived，若转换失败则导致崩溃
let d = c as Base     // 类型为 Base，向下转换必然成功

结构体 struct

与 C++ 不同，Swift 中的 struct 和 class 有共同之处，但并不能等同。

struct 与 class 类似，可以定义成员变量、成员函数、静态成员、构造函数，访问控制与类相同。

它们之间的不同点有：

  • struct 是值类型。也就是说，传递的是原有实例的副本，而非引用
  • struct 没有继承
  • struct 不能定义析构函数

struct 由于没有继承，因此对成员的构造函数（英语：Memberwise initializer）能够自动生成，大多数情况下无需手动写构造函数：

struct A {
    var foo: Int
    var bar: String
}

let a = A(foo: 1, bar: "Hello")

另外，struct 的成员函数默认不可更改成员变量，如果需要更改，则需要在函数前加上 mutating：

struct Counter {
    var count = 0
    mutating func increase() {
        count += 1
    }
}

枚举 enum

Swift 的 enum 提供了一种类型安全的枚举方法。

enum CompassPoint {
    case north, south, east, west
}

var directionToHead = CompassPoint.north

enum 可以使用 switch 语句来匹配：

directionToHead = .south
switch directionToHead {
case .north:
    print("Lots of planets have a north")
case .south:
    print("Watch out for penguins")
case .east:
    print("Where the sun rises")
case .west:
    print("Where the skies are blue")
}

或者用 == 判断：

if directionToHead == .north {
    print("我飘向北方")
}

迭代

可以在 enum 后面加上 CaseIterable 使得可以按照声明顺序枚举所有的类型：

enum CompassPoint: CaseIterable {
    case north, south, east, west
}

for point in CompassPoint.allCases {
    ...
}

原始值

enum 可以有一个原始值（raw value）类型，可以是 Int，String 等等，可以用来初始化 enum 类型。如果不指定值，编译期会自动设置对应的值，如 Int 是从 0 开始赋值并依次递增，而 String 对应各个 case 的名称。

enum Status: Int {
    case onVacation     // 0
    case atSchool = 10
    case quit           // 11
}

print(Status.onVacation.rawValue)   // 0
let status = Status(rawValue: 5)    // nil
let status = Status(rawValue: 10)   // Optional(Status.atSchool)

关联值

enum 的每个 case 可以储存一个或多个关联值（associated value）。需要注意，一旦储存了关联值，就不能够指定 raw value，也不能够通过 == 判断是否相等：

enum Food {
    case hamburger(calories: Double)
    case juice(amount: Double)
}


let breakfast = Food.hamburger(calories: 294.9)

switch breakfast {
case .hamburger(let calories):
    print("I ate a hamburger with \(calories) calories")
default:
    break
}

// or
if case .hamburger(let calories) = breakfast {
    print("I ate a hamburger with \(calories) calories")
}

函数、构造函数和变量

enum 是 Swift 的一等类型，它可以有成员函数、构造函数、计算变量、静态函数、静态变量，但不能储存值，即不能拥有成员变量。

能够给 enum 添加函数等给编程带来了极大的便利：

enum HTTPError: Int {
    case unknown
    case badRequest = 400
    case notFound = 404
    case forbidden = 403

    init(code: Int) {
        if let error = HTTPError(rawValue: code) {
            self = error
        } else {
            self = .unknown
        }
    }

    var description: String {
        switch self {
        case .badRequest: return "Bad Request"
        case .notFound: return "Not Found"
        ...
        }
    }
}

let error = HTTPError(code: 404)
print(error.description)            // "Not Found"

另外，一般使用 enum 加上静态变量来限定命名空间：

enum Constant {
    static let accentColor = Color.blue
    static let backgroundColor = Color.white
}

let color = Constant.accentColor

协议 protocol

Swift 中的 protocol（协议）与 C++ 的抽象类概念对应，其作用是定义一组需要实现的接口。比如，Swift 中的 Equatable，其作用是一个判等器：

protocol Equatable {
    static func == (lhs: Self, rhs: Self) -> Bool
}

满足协议要求的类型称为遵循（conform to）此协议。如果一个类型想要遵循 Equatable，需要：

  1. 在类型名称后面加上 Equatable
  2. 实现 == 方法

比如：

struct Rectangle: Equatable {
    var width: Double
    var height: Double

    static func == (lhs: Rectangle, rhs: Rectangle) -> Bool {
        return lhs.width == rhs.width && lhs.height == rhs.height
    }
}

let r1 = Rectangle(width: 1, height: 3)
let r2 = Rectangle(width: 1, height: 2)
print(r1 == r2)     // false

let rectangles = [r1, r2]   // An array of rectangles
print(rectangles.contains(Rectangle(width: 1, height: 2)))  // true

在这里，Array 本身并不知道如何判断它其中是否有元素与提供的 Rectangle 相等，但由于 Rectangle 遵循了 Equatable 协议，使得 Array 可以调用 Equatable 规定的判等接口来实现判断。

接口的规定方法

protocol 可以规定几类接口：

  • 成员函数
  • 成员变量
  • 静态函数
  • 静态变量
  • 构造函数
protocol SomeProtocol {
    var foo: Int { get set }
    var bar: Int { get }
    static var staticMember: Int { get }

    func someMethod(a: Int) -> Int
    static func staticMethod() -> Bool
    init(code: Int)
}

其中，规定变量的接口时，只能用 var，而且需要在类型名后加上 { get } 或 { get set } 以指定需要满足的最小权限要求。比如，某个类型遵循 SomeProtocol 时，它的 foo 变量需要可读写，而 bar 变量至少可以读，但不能限制其是否可写。

协议作为类型

当没有 associated type（稍后介绍）时，协议可以作为类型，并且其真正的类型可以改变，如 Swift 中内置的 Encodable：

var someEncodable: Encodable = 1
someEncodable = "Hello"

协议方法的默认实现

在规定了协议的接口后，可以在 extension 中对除了 init 以外的接口进行默认实现，但不能在 extension 中实现储存变量：

extension SomeProtocol {
    var bar: Int {
        return 1
    }
    func someMethod(a: Int) -> Int {
        return a
    }
}

这样，当某个类型遵循 SomeProtocol 时，可以不用实现这些已经进行默认实现的接口。

协议的组合与继承

一个类型可以遵循多个协议，需要实现所有协议规定的接口：

protocol A {
    var foo: Int { get }
}
protocol B {
    func bar()
}

struct: SomeStructure: A, B {
    var foo: Int
    func bar() {...}
}

一个协议可以继承多个协议，其作用为添加这些协议的规定的接口作为自身的限制条件，需要实现所有的接口：

protocol A {
    var foo: Int { get }
}
protocol B: A {
    func bar()
}

struct: SomeStructure: B {
    var foo: Int
    func bar() {...}
}

extension

class、struct、enum 和 protocol 可以通过 extension 添加方法（计算变量或函数），包括所有的内置类型：

extension Int {
    var string: String {
        return "\(self)"
    }
}

print(1.string)

使用 extension 可以以面向对象的方式给任何类型添加方法。

另外，一般为了区分不同的 protocol 的接口，在遵循不同的协议时，往往将各个协议规定的接口实现在不同的 extension 中：

struct A {
    // Original members
}
extension A: ProtocolA {
    // Implementation of ProtocolA
}
extension A: ProtocolB {
    // Implementation of ProtocolB
}

元组

元组（tuple）用于传递复合值，用括号组织，可以带标签，用标签或者成员（而非下标）0、1、2 等取出其中的值：

func getCurrentTime() -> (hour: Int, minute: Int, second: Int) {
    return (18, 20, 36)
}

let time = getCurrentTime()
print(time.hour)
// or
print(time.0) // hour

元组的元素数量是固定的，不存在越界的情况。

函数

Swift 中，函数也是一种类型，可以储存在变量中，也可以作为参数/返回值参与另一个函数。函数类型的声明为 (参数列表) -> 返回类型：

var someHandler: (Int, Int) -> Void
var optionalHandler: ((Int, Int) -> Void)? // Optional

使用大括号来生成匿名函数（闭包，closure），在括号内使用 参数列表 -> 返回类型 in 给传入的各个参数命名：

let incrementer: (Int) -> Int = { value -> Int in
    return value + 1
}

调用方法与函数相同：

let result = incrementer(1) // 2

上下文明确时，可以省略括号内的 -> Int：

let incrementer: (Int) -> Int = { value in
    return value + 1
}

另外，可以省略参数列表，用 $0、$1 等指代第一、第二个元素：

let incrementer: (Int) -> Int = {
    return $0 + 1
}

[1, 2, 3].removeAll(where: { $0 < 2 })  // [2, 3]