Swift – 特性小记一

for case let

for case let 语法是对正在遍历的列表加上条件，只有满足条件的才会进入循环

1、表示循环的数组中是可选值，使用 for case let 可选变量，此时 for 代码域中拿到的值是除了 nil 之外的值：

let citys = ["北京", "上海", "深圳", "广州", nil, "重庆"]
for case let city? in citys {
    print(city)
}
输出如下
北京
上海
深圳
广州
重庆

2、检查数组中的类型是否符合条件

/*检查 view 的子视图中是否 为 UILable 类型，如果是 在进入 for 代码域*/
 for case let label as UILabel in view.subViews {
      print(label)
 }

以上两种是典型的 for case let 的用法

多重循环终止外层循环

对循环设定一个标签，当需要终止该外层循环时，调用 break <标签>

如下是常见的跳过循环：当遇到 break 时，只是跳过当前层的循环

for _ in 0...10 {
     for j in 1...10 {
         if 10/j == 2 {
             print("打印")
             break
         }
     }
 }
/* 以上的 break 只是跳过当前的 for 循环，会打印11次 */

而设置 for 循环标签后，可以跳过指定标签的 for/while 循环

firstLoop: for _ in 0...10 {
     for j in 1...10 {
         if 10/j == 2 {
             print("打印")
             break firstLoop
         }
     }
 }
 /* 以上定义了 外层 for 循环的标签，break 外层 for 循环标签会跳过外层 for 循环
  因此以上打印只有一次 */

defer

defer 的意思是最后执行的代码，一般用于对内存的释放什么的

func contents() {
     /* 打开数据库 */
     defer {
         /* 关闭数据库 */
     }
     /* 查询数据库 */
 }

static 修饰和 class 修饰的区别

static 和 class 都可以修饰表示被修饰的方法、属性为类型方法、类型属性。但有几个区别：

protocol 中要使用 static 修饰来表示方法或者计算属性是类型域上的
用 static 修饰的方法、属性不能被继承
static 可以修饰方法、计算属性、存储属性；class 只能修饰方法、计算属性

final 修饰符

final 修饰的类是最终类，不能被继承

final 修饰的方法不能被子类重写

final 修饰的属性不能被子类重写
Extension

extension 类似与 OC 中的 Category的功能，但是 Swift 中的 extension 可以拓展协议，为 protocol 提供默认实现（这是协议编程的基础）

Swift 中的 protocol extension 默认实现也是 Swift 类 protocol extension 的可选方法的实现方式

属性声明时被赋值另一个属性在 Swift 中是不允许的

因为 Swift 不知道属性的创建顺序，因此是不允许的，会直接报错，如：

Cannot use instance member 'defaultDate' within property initializer; property initializers run before 'self' is available

class TestProtity: NSObject {
    private var date = defaultDate

    var defaultDate: Date {
        var components = DateComponents()
        components.hour = 8
        components.minute = 0
        let date = Calendar.current.date(from: components) ?? Date.now
        return date
    }

}

struct TestProtity {
    private var date = defaultDate

    var defaultDate: Date {
        var components = DateComponents()
        components.hour = 8
        components.minute = 0
        let date = Calendar.current.date(from: components) ?? Date.now
        return date
    }

}

这种情况下，如果一定要这么处理业务，那就要将赋值的那个属性标记为类或结构体属性，这样就不会报错

class TestProtity: NSObject {
    private var date = defaultDate

    static var defaultDate: Date {
        var components = DateComponents()
        components.hour = 8
        components.minute = 0
        let date = Calendar.current.date(from: components) ?? Date.now
        return date
    }
}

struct TestProtity {
    private var date = defaultDate

    static var defaultDate: Date {
        var components = DateComponents()
        components.hour = 8
        components.minute = 0
        let date = Calendar.current.date(from: components) ?? Date.now
        return date
    }
}

Swift 中的 protocol 的可选方法

Swift 协议中的可选方法分两种

适配 OC 的可选
纯粹 Swift 的可选

适配 OC 的可选

需要将协议标记为 @objc

且需要将可选方法也标记为 @objc

@objc protocol RentalCar {
    var name: String { get }
    var passengers: Int { get }
    var pricePerDay: Float { get }
    @objc optional func createRentalCar() -> RentalCar?
}

纯粹 Swift 的可选

纯粹的 Swift 的协议可选其实就是利用 Swift 协议拓展进行默认方法实现来实现协议方法的可选的

protocol RentalCar {
    var name: String { get }
    var passengers: Int { get }
    var pricePerDay: Float { get }
    func createRentalCar() -> RentalCar?
}

extension RentalCar {
    func createRentalCar() -> RentalCar? {
        return nil
    }
}