Swift语言学习笔记（2）

最新推荐文章于 2019-09-12 13:21:22 发布

zwvista

最新推荐文章于 2019-09-12 13:21:22 发布

阅读量1k

点赞数

分类专栏： Swift

本文链接：https://blog.csdn.net/zwvista/article/details/48176405

版权

Swift 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

枚举（Enumerations）

Swift语言中的枚举是一种相关值的联合类型。在枚举类型中可以定义一组相关的名字或者值，但在某一时刻枚举变量的值只能属于其中一个值。
枚举大致可分为三种：名字的枚举，相同类型值的枚举，不同类型值的枚举。

名字的枚举没有值，或者说名字本身就是值。

// 名字的枚举
enum CompassPoint {
    case north
    case south
    case east
    case west
}
enum CompassPoint {
    case north, south, east, west
}
var directionToHead = CompassPoint.west
directionToHead = .east
switch directionToHead {
case .north:
    // ...
case .south:
    // ...
case .east:
    // ...
case .west:
    // ...
}
switch directionToHead {
case .north:
    // ...
default:
    // ...
}

相同类型值的枚举带有原始值（Raw Values），原始值的类型必须是字符，字符串，整形或者浮点型。

// 相同类型的枚举
enum ASCIIControlCharacter: Character {
    case tab = "\t"
    case lineFeed = "\n"
    case carriageReturn = "\r"
}
enum CompassPoint: String {
    case north, south, east, west
}
// CompassPoint.South.rawValue is "South"
enum CompassPoint: Int {
    case north = 1, south, east, west
}
// CompassPoint.South.rawValue is 2
let directionToHead = CompassPoint(rawValue: 2)
// directionToHead is of type CompassPoint? and equals CompassPoint.south
let directionToFind = 2
if let directionToHead = Planet(rawValue: directionToFind) {
    switch somePlanet {
    case .north:
        // ...
    default:
        // ...
    }
} else {
    // ...
}

不同类型值的枚举带有相关值（Associated Values）。
在其他语言中这类枚举通常被称为可辨识的联合（discriminated unions）或是变体（variants）。

// 不同类型的枚举
enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}
var productBarcode = Barcode.upc(8, 85909, 51226, 3)
productBarcode = .qrCode("ABCDEFGHIJKLMNOP")
switch productBarcode {
case .upc(let numberSystem, let manufacturer, let product, let check):
    // ...
case . qrCode(let productCode):
    // ...
}
switch productBarcode {
case let .upc(numberSystem, manufacturer, product, check):
    // ...
case let .qrCode(productCode):
    // ...
}

// 计算周长
enum Shape {
    case square(sidelen: Double)
    case circle(perimeter: Double)
}
let s = Shape.square(sidelen: 3)
let s2 = Shape.circle(perimeter: 3)
switch(s2) {
    case .square(let sidelen): print(sidelen * 4)
    case .circle(let perimeter): print(perimeter * 3.14)
}
// 9.42

不同类型值的枚举可以定义自我递归的值。

// 自我递归的枚举
enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}
indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}
func evaluate(expression: ArithmeticExpression) -> Int {
    switch expression {
    case .number(let value):
        // ...
    case .addition(let left, let right):
        // ...
    case .multiplication(let left, let right):
        // ...
    }
}
let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)
let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))
print(evaluate(product))

类和结构（Classes and Structures）

类和结构的共同点：都可以定义方法，属性，下标以及构造器，都可以定义扩展，都可以遵守协议。
类和结构的不同点：结构和枚举属于值类型，类属于引用类型。
值类型的拷贝属于深拷贝（拷贝值），引用类型的拷贝属于浅拷贝（拷贝引用）。
值类型使用 == 以及 != 运算符来比较值。引用类型使用 === 以及 !== 运算符来比较引用。
类所具有的额外功能：类可以定义析构器，可以继承其他的类。类的实例通过引用计数来管理。
结构所具有的额外功能：具有缺省的成员逐一构造器。
String, Array, Dictionary是结构。
NSString, NSArray, NSDictionary是类。

属性（Properties）

在类型（类，结构，枚举）中定义的值被称为属性。
字段属性
Java 有无
C# 有有
Swift 无有

	字段	属性
Java	有	无
C#	有	有
Swift	无	有

按存储方式分，属性可分为：存储属性（stored properties 存储在常量或变量中的属性）和计算属性（computed properties 经过计算由get返回由set设置的属性）。
存储属性可以加上懒惰（lazy）标签，表示属性初始化时间延后至属性初次访问时。
存储属性可以加上属性观测器（property observers），用于监视对属性的访问。willSet观测器在属性设置之前被调用，didSet观测器则在属性设置之后被调用。

	（可读可写）存储属性	只读存储属性	懒惰存储属性	（可读可写）计算属性	只读计算属性
示例	var v: Int var v = 10 var v = 10 { willSet {print(newValue)} didSet {print(oldValue)} }	let v: Int let v = 10	lazy var v = V()	var v: Int { get {return ...} set {... = newValue} }	var v: Int { return ... }
计算并设置属性值的时间	类型初始化时	类型初始化时	属性初次访问时	属性每次访问时	属性每次访问时

按所有者分，属性可分为：实例属性（instance properties 附属于类型实例的属性）和类型属性（type properties 附属于类型本身的属性）。
关键字类结构枚举
实例属性无无／
类型属性 static
class static static

关键字	类	结构	枚举
实例属性	无	无	／
类型属性	static class	static	static

方法（Methods）

在类型（类，结构，枚举）中定义的函数被称为方法。
方法有两种：实例方法（instance methods 由类型实例调用的方法）和类型方法（type methods 由类型本身调用的方法）。
关键字类结构枚举
变动性实例方法无 mutating mutating
非变动性实例方法无无无
类型方法 static
class static static

关键字	类	结构	枚举
变动性实例方法	无	mutating	mutating
非变动性实例方法	无	无	无
类型方法	static class	static	static

下标（Subscripts）

下标可以被看成一种带参数的计算属性，也可以被看成一种自定义的[]运算符。
下标的经典使用场景：数组，字典，矩阵。

// 在矩阵结构中定义下标
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
        }
    }
}
var matrix = Matrix(rows: 2, columns: 2)
matrix[0, 1] = 1.5