swift 新特性 - WWDC22

Swift Packages 更新

Trust on first use (TOFU)

• 新的安全协议，其中在首次下载包时记录包的指纹

• 后续下载将验证此指纹，如果指纹不同，则报告错误

插件

命名冲突

let package = Package(
  name: "MyStunningApp",
  dependencies: [
    .package(url: "https://.../swift-metrics.git"),
    .package(url: "https://.../swift-log.git") // ⚠️ swift-log and swift-metric define a Logging module
  ],
  targets: [
    .executableTarget(
      name: "MyStunningApp",
      dependencies: [
        .product(name: "Logging", package: "swift-log"),
        .product(name: "Metrics", package: "swift-metrics",
                 moduleAliases: ["Logging": "MetricsLogging"]), // 👈🏻 module aliasing
])])

Swift 底层性能优化

• 编译时间提升
• 更快的泛型类型检查

• 运行时改进
• Swift5.7 会对协议一致性检查进行缓存，提高编译速度。

• Swift driver(Swift 编译器驱动程序)
• Xcode 现在已经将 Swift driver 集成到构建系统内部，而不是一个独立的可执行文件，提高了项目构建速度。

Swift 并发模型

安全检查

distributed Actors

distributed actor Player {

    var ai: PlayerBotAI?
    var gameState: GameState

    distributed func makeMove() -> GameMove {
        return ai.decideNextMove(given: &gameState)
    }
}

其他优化

Swift 语言优化

If let 简写优化

if let name = name {
    print("Hello, \\(name)!")
}

if let unwrappedName = name {
    print("Hello, \\(unwrappedName)!")
}

var name: String? = "Linda"

if let name {
    print("Hello, \\(name)!")
}

struct User {
    var name: String
}

let user: User? = User(name: "Linda")

if let user.name {
    print("Welcome, \\(user.name)!")
}

返回类型推断

let oldResults = scores.map { score -> String in
    if score >= 85 {
        return "\\(score)%: Pass"
    } else {
        return "\\(score)%: Fail"
    }
}

let scores = [100, 80, 85]

let results = scores.map { score in
    if score >= 85 {
        return "\\(score)%: Pass"
    } else {
        return "\\(score)%: Fail"
    }
}

允许指针类型转换

正则表达式

let message = "the cat sat on the mat"
print(message.ranges(of: "at"))
print(message.replacing("cat", with: "dog"))
print(message.trimmingPrefix("the "))

print(message.ranges(of: /[a-z]at/))
print(message.replacing(/[a-m]at/, with: "dog"))
print(message.trimmingPrefix(/The/.ignoresCase()))

do {
    let atSearch = try Regex("[a-z]at")
    print(message.ranges(of: atSearch))
} catch {
    print("Failed to create regex")
}

let search3 = Regex {
    "My name is "

    Capture {
        OneOrMore(.word)
    }

    " and I'm "

    Capture {
        OneOrMore(.digit)
    }

    " years old."
}

let search4 = Regex {
    "My name is "

    Capture {
        OneOrMore(.word)
    }

    " and I'm "

    TryCapture {
        OneOrMore(.digit)
    } transform: { match in
        Int(match)
    }

    Capture(.digit)

    " years old."
}

let nameRef = Reference(Substring.self)
let ageRef = Reference(Int.self)

let search5 = Regex {
    "My name is "

    Capture(as: nameRef) {
        OneOrMore(.word)
    }

    " and I'm "

    TryCapture(as: ageRef) {
        OneOrMore(.digit)
    } transform: { match in
        Int(match)
    }

    Capture(.digit)

    " years old."
}

if let result = greeting.firstMatch(of: search5) {
    print("Name: \\(result[nameRef])")
    print("Age: \\(result[ageRef])")
}

基于默认表达式的类型推断

func compute<C: Collection>(_ values: C = [0, 1, 2]) {}

不透明的参数声明

func isSorted(array: [some Comparable]) -> Bool {
    array == array.sorted()
}

func isSortedOld<T: Comparable>(array: [T]) -> Bool {
    array == array.sorted()
}

返回不透明的泛型

func showUserDetails() -> (some Equatable, some Equatable) {
    (Text("Username"), Text("@twostraws"))
}

func createUser() -> [some View] {
    let usernames = ["@frankefoster", "@mikaela__caron", "@museumshuffle"]
    return usernames.map(Text.init)
}

func createDiceRoll() -> () -> some View {
    return {
        let diceRoll = Int.random(in: 1...6)
        return Text(String(diceRoll))
    }
}

总结

其他

时间标准

extension Task {
    @available(*, deprecated, renamed: "Task.sleep(for:)")
    public static func sleep(_ duration: UInt64) async

    @available(*, deprecated, renamed: "Task.sleep(for:)")
    public static func sleep(nanoseconds duration: UInt64) async throws

    public static func sleep(for: Duration) async throws

    public static func sleep<C: Clock>(until deadline: C.Instant, tolerance: C.Instant.Duration? = nil, clock: C) async throws
}

基于默认表达式的类型推断

func compute<C: Collection>(_ values: C = [0, 1, 2]) {
}