Swift学习之5.1和5.2新特性

Swift 5.1 新特性

Swift 5.1 内置于 Xcode 11，新增了很多新特性，比较重要的有以下几个。

静态成员的Self

Swift 5.1之后，可以使用Self替代类名来访问静态成员。

class Student {    
    static var age = 10
    
    static func study(){
        print("Good Study")
    }
    
    func say(){
        print(Self.age)  // 访问静态属性
        Self.study()  // 访问静态方法
    }    
}

let stu = Student()
stu.say()

Key Path元组

Swift 5.1 可以在Key Path中使用元组，通过.访问元素。

struct Student  {    
    var name: String
    var age: Int
    var score: (Swift: Double, iOS: Double, Mac: Double)
}

let stu = Student(name: "zhangsan", age: 20, score: (Swift: 88.0, iOS: 90.0, Mac: 95.0))

// 访问元组的元素
let swift = stu[keyPath:\Student.score.Swift]
let ios = stu[keyPath:\Student.score.iOS]
let mac = stu[keyPath:\Student.score.Mac]

@dynamicMemberLookup查找Key Path

Swift 5.1 实现了@dynamicMemberLookup查找Key Path。

struct Person { 
    var name: String
    var age: Int
}

@dynamicMemberLookup
struct Student {
    
    var stuNo: String
    var person: T
    
    // 实现方法
    subscript(dynamicMember member: KeyPath) -> U {
       
        person[keyPath: member]
    }
}

let p = Person(name: "zhangsan", age: 20)
let stu = Student(stuNo: "123456789", person: p)

// 可以直接访问 name 和 age 属性
stu.name
stu.age

函数、闭包单表达式的隐式返回

解读：如果一个闭包或者函数只包含一个返回表达式，那么可以把return省略掉，隐式返回该表达式。

func add(a: Int, b: Int) -> Int {
    a + b
}
add(a: 10, b: 20)

struct Rectangle {
    var width = 0.0, height = 0.0
    var area: Double { 
        width * height 
    }
}

根据默认值合成结构体的构造函数

解读：以前一个结构体的所有属性都有默认值时，编译器会基于属性生成两个构造函数。
结构体名()和结构体名(所有属性参数)，但是并不会生成可选属性参数的构造函数，Swift 5.1 之后可以了。

struct Person {
  var age = 0
  var name = "zhangsan"
}

以下都是正确的构造函数

let zhangsan = Person()
let lisi = Person(age: 20, name: "lisi")
let wangwu = Person(name: "wangwu")

不透明的返回类型（Opaque Result Types）

一个案例引发的血案

// 报错：Protocol 'Equatable' can only be used as a generic constraint because it has Self or associated type requirements
func generateIntNumber() -> Equatable {
    return 5
}

let number1 = generateIntNumber()
let number2 = generateIntNumber()

// 报错：Binary operator '==' cannot be applied to two 'Equatable' operands
if number1 == number2 {
    print("numbers equal")
}

Swift5.1之前解决

// 使用泛型约束
func generateIntNumber() -> T {    
    // 强制转换
    return 5 as! T
}

let number1: Int = generateIntNumber()
let number2: Int = generateIntNumber()

if number1 == number2 {
    print("numbers equal")
}

但如果此时把: Int去掉，会发现依然报错，因为返回的类型是一个不确定的T。

Swift5.1解决

// 用some修饰，返回值的类型对编译器就变成透明的了。在这个值使用的时候编译器可以根据反回值进行类型推断得到具体类型。
func generateIntNumber() -> some Equatable {
    return 5
}

// 此时number1和number2的类型是some Equatable
let number1 = generateIntNumber()
let number2 = generateIntNumber()


if number1 == number2 {
    print("numbers equal")
}

如果将generateIntNumber改一下，又会出现问题:

// 报错：Function declares an opaque return type, but the return statements in its body do not have matching underlying types
func generateIntNumber() -> some Equatable {
    if Bool.random() {
        return 5
    }
    else {
        return "5"
    }
}

// 此时number1和number2的类型是some Equatable
let number1 = generateIntNumber()
let number2 = generateIntNumber()

if number1 == number2 {
    print("numbers equal")
}

概念

• 在保持性能的同时，隐藏真实类型的新功能。
• 通过引入some这个关键字去修饰返回值，语法上隐藏具体类型，所以叫做不透明结果类型，这样可以让被调用方选择具体的返回值类型，并且是在编译时确定下来的。
• 允许带有Self或者associatedtype的 protocol 作为返回类型。
• 再看一个案例

protocol Animal {
    associatedtype Element
    
    func feed(food: Element)
}
struct Cat: Animal {
    typealias Element = String    
    
    func feed(food: String) {
        print("Cat eat \(food)")
    }
}

// 会发现这行报错：Protocol 'Animal' can only be used as a generic constraint because it has Self or associated type requirements
//func makeAnimal() -> Animal {
//    return Cat()
//}

// 从返回值看不出具体类型
func makeAnimal() -> some Animal {
    return Cat()
}

let animal = makeAnimal()
type(of: animal)

作用

• SwiftUI 中广泛使用

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello World")
    }
}

属性包装类型（Property Wrapper Types）

基于 Swift 的 iOS 开发中，越来越多@修饰的关键字出现，比如@UIApplicationMain，在最新的 SwiftUI 框架中，会发现这样的关键字越来越多，比如@State，@Binding，@EnvironmentObject等，它们共同构成了 SwiftUI 数据流的基本单元，这些知识点会随着学习 SwiftUI 而深入了解。

• 关键字@propertyWrapper，用它修饰一个结构体，它修饰的结构体可以变成一个新的修饰符并作用在其他代码上，来改变这些代码默认的行为。
• 用修饰符@结构体名去修饰其他的属性，将属性“包裹”起来，从而控制某个属性的行为。属性包装类型名字由此而来。
• 案例

@propertyWrapper struct Trimmed {
    
    private var value: String = ""
    // 计算属性
    var wrappedValue: String {
        get { value }
        set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
    }

    init(wrappedValue initialValue: String) {
        self.wrappedValue = initialValue
    }
}

struct Post {
    // 用上面定义的Trimmed修饰同类型的变量
    @Trimmed var title: String
    @Trimmed var body: String
}
// 任何字符串无论是在初始化期间还是通过后面的属性访问都会自动删除前后面的空格。
var post = Post(title: "  Swift Property Wrappers  ", body: " is very important ")
post.title  // "Swift Property Wrappers"
post.body  // "is very important"

post.title = "      @propertyWrapper     "
post.title  // "@propertyWrapper"

Swift 5.2 新特性

Swift 5.2 内置于 Xcode 11.4，Swift 5.2 并不像 Swift 5.1 那样增加了很多新特性，主要有以下几点更新。

将 Key Path 表达式作为函数

• 可以像调用函数一样使用关键路径表达式。
• 配合高阶函数可以进一步简化代码。
• 适用于结构体与类。

// 结构体
struct Student {
    var stuName: String
    var stuClass: String
    var stuAge: Int
    var canVote:Bool {
        return stuAge > 18
    }
}

// 构造三个实例并放入数组
let zhangsan = Student(stuName: "张三", stuClass: "移动互联应用技术", stuAge: 17)
let lisi = Student(stuName: "李四", stuClass: "云计算技术与应用", stuAge: 18)
let wangwu = Student(stuName: "王五", stuClass: "大数据技术与应用", stuAge: 19)
let stus = [zhangsan, lisi, wangwu]

// 1. 获取所有人的名字
let stuNames = stus.map(\.stuName)
// ["张三", "李四", "王五"]

// 2. 筛选年龄达到可以投票的学生
let stuNo = stus.filter(\.canVote)
// [{stuName "王五", stuClass "大数据技术与应用", stuAge 19}]

可调用类型

• 如果一个值是通过类型中名为callAsFunction的方法实现的，那么可以直接通过语法该类型的实例()获取该值。
• 适用于结构体与类。

// 结构体
struct Student {
    var stuName: String
    var stuClass: String
    var stuAge: Int
    
    // 声明一个callAsFunction的函数，返回值根据需要调整
    func callAsFunction() -> String {
        if stuAge > 18 {
            return "具有投票权"
        }
        return "不具有投票权"
    }
}

let zhangsan = Student(stuName: "张三", stuClass: "移动互联应用技术", stuAge: 17)
// 直接通过对象调用
print(zhangsan()) // "不具有投票权"，等价于 zhangsan.callAsFunction()

let lisi = Student(stuName: "李四", stuClass: "云计算技术与应用", stuAge: 19)
print(lisi()) // "具有投票权"

新的改进的诊断体系

引入了一种新的诊断体系结构来提高 Xcode 发出的错误消息的质量和精度。这在使用 SwiftUI 编写代码时尤其明显，写过 SwiftUI 的都知道经常 Xcode 发出的错误信息经常是不准确的。

Swift5.2之前

import SwiftUI

struct ContentView: View {
    
    @State private var name = 0

    var body: some View {
        HStack {
            Text("姓名")
            TextField("请输入姓名", text: $name)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                // Swift 5.2之前会提示下面一行有个错误
                .frame(maxWidth: 300) // 错误信息：'Int' is not convertible to 'CGFloat?'
        }
    }
}

写过 SwiftUI 的第一次看见这个错误肯定觉得奇怪（嗯？300 没错误啊！），其实这并不是错误的真正原因。从语法来分析，错误的真正原因是TextField需要绑定一个String类型的Binding值，而在定义的时候由于name赋值为0导致其类型为Int，所以绑定值的类型不匹配才是真正的错误原因。

Swift5.2

import SwiftUI

struct ContentView: View {
    
    @State private var name = 0
    
    var body: some View {
        HStack {
            Text("姓名")
            TextField("请输入姓名", text: $name)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .frame(maxWidth: 300) // Swift 5.2的错误信息
                // Cannot convert value of type 'Binding' to expected argument type 'Binding'
        }
    }
}

很明显，新的诊断体系结构给出的错误信息是准确的，这样就可以快速定位 SwiftUI 的错误，提高开发的效率。