Swift 5.4 新特性

Swift 5.4 带来了一些巨大的编译改进，包括表达式中具有错误的更好的代码完成和增量编译的大幅度提高。但是，它也增加了一些重要的新功能和改进，因此让我们在这里进行深入研究...

改进的隐式成员语法

SE-0287(https://github.com/apple/swift-evolution/blob/main/proposals/0287-implicit-member-chains.md) 提高了 Swift 使用隐式成员表达式的能力，不仅支持引用静态成员，还可以为其建立链式调用。

Swift 一直具有对简单表达式使用隐式成员语法的能力，例如，如果您想在 SwiftUI 中为某些文本着色，则可以使用 .red 而不是 Color.red：

struct ContentView1: View {
    var body: some View {
        Text("You're not my supervisor!")
            .foregroundColor(.red)
    }
}

在 Swift 5.4 之前，这不适用于更复杂的表达式。例如，如果您希望红色略微透明，则需要编写以下代码：

struct ContentView2: View {
    var body: some View {
        Text("You're not my supervisor!")
            .foregroundColor(Color.red.opacity(0.5))
    }
}

从 Swift 5.4 起，编译器可以支持多个链式的成员，这意味着可以推断 Color 类型：

struct ContentView3: View {
    var body: some View {
        Text("You're not my supervisor!")
            .foregroundColor(.red.opacity(0.5))
    }
}

函数中的多个可变参数

SE-0284(https://github.com/apple/swift-evolution/blob/main/proposals/0284-multiple-variadic-parameters.md) 引入了让函数、下标和初始化器可以使用多个可变参数的功能，只要可变参数后面的所有参数都带有标签。在 Swift 5.4 之前，在这种情况下，您只能有一个可变参数。

有了这一改进，我们可以编写一个函数来接受一个可变参数，该参数存储足球比赛期间进球的时间，以及第二个可变参数，用于对得分球员的姓名进行评分：

func summarizeGoals(times: Int..., players: String...) {
    let joinedNames = ListFormatter.localizedString(byJoining: players)
    let joinedTimes = ListFormatter.localizedString(byJoining: times.map(String.init))

    print("\(times.count) goals where scored by \(joinedNames) at the follow minutes: \(joinedTimes)")
}

要调用该函数，请提供两组值作为可变参数，并确保第一个可变参数之后的所有参数带标记为：

summarizeGoals(times: 18, 33, 55, 90, players: "Dani", "Jamie", "Roy")

Result 构建器

Swift 5.1 非正式引入了函数 builder，但是在 Swift 5.4 之前，他们正式通过了 SE-0289 的 Swift Evolution proposal 过程，以便进行讨论和完善。作为该 proposal 的一部分，它们被重命名为 Result 构建器，以更好地反映其实际目的，甚至还有一些新功能。

首先，最重要的部分是：Result 构建器允许我们通过传递选择的顺序逐步创建新的值。它们为 SwiftUI 的视图创建系统的大部分提供了支持，因此，当我们拥有一个内部包含各种视图的 VStack 时，Swift 会将它们静默地分组为内部 TupleView 类型，以便可以将其存储为 VStack 的单个子级 – 将一系列视图合并为一个视图。

这里给一些小代码示例，以便您可以实际地了解它们。

这是一个返回单个字符串的函数：

func makeSentence1() -> String {
    "Why settle for a Duke when you can have a Prince?"
}

print(makeSentence1())

效果很好，但是如果我们想将多个字符串连接在一起怎么办？就像 SwiftUI 一样，我们可能想单独提供它们，并让 Swift 得出结果：

// This is invalid Swift, and will not compile.
// func makeSentence2() -> String {
//     "Why settle for a Duke"
//     "when you can have"
//     "a Prince?"
// }

该代码将无法工作，因为 Swift 不理解我们的意思。但是，我们可以创建一个 Result 构建器，该构建器了解如何使用所需的任何转换将多个字符串转换为一个字符串，如下所示：

@resultBuilder
struct SimpleStringBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: "\n")
    }
}

虽然代码量很少，但有很多需要解构的东西：

• @resultBuilder属性告诉 SwiftUI 以下类型应视为结果生成器。以前，此行为是使用 @_functionBuilder 来实现的，其下划线表示该代码不是为一般用途而设计的。
• 每个结果生成器必须提供至少一个称为 buildBlock() 的静态方法，该方法应获取某种数据并将其转换。上面的示例接收零个或多个字符串，将它们连接起来，然后将它们作为单个字符串发送回去。
• 最终结果是我们的 SimpleStringBuilder 结构成为结果生成器，这意味着我们可以在需要其字符串连接能力的任何地方使用 @SimpleStringBuilder。

我们可以像下面这样直接使用 SimpleStringBuilder.buildBlock()：

let joined = SimpleStringBuilder.buildBlock(
    "Why settle for a Duke",
    "when you can have",
    "a Prince?"
)

print(joined)

但是，因为我们在 SimpleStringBuilder 结构中使用了 @resultBuilder 批注，所以我们也可以将其应用于函数，如下所示：

@SimpleStringBuilder func makeSentence3() -> String {
    "Why settle for a Duke"
    "when you can have"
    "a Prince?"
}

print(makeSentence3())

请注意，我们不再需要在每个字符串的末尾添加逗号 – @resultBuilder 使用 SimpleStringBuilder 将 makeSentence() 中的每个语句自动转换为单个字符串。

实际上，通过将更多方法添加到您的构建器类型中，结果构建器可以实现更多功能。例如，我们可以通过添加两个额外的方法来描述我们想如何转换数据，从而为 SimpleStringBuilder 添加 if/else 支持。在我们的代码中，我们根本不需要转换字符串，因此我们可以立即将它们发送回去：

@resultBuilder
struct ConditionalStringBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: "\n")
    }

    static func buildEither(first component: String) -> String {
        return component
    }

    static func buildEither(second component: String) -> String {
        return component
    }
}

我知道看起来我们几乎没有做任何工作，但是现在我们的函数可以使用条件了：

@ConditionalStringBuilder func makeSentence4() -> String {
    "Why settle for a Duke"
    "when you can have"

    if Bool.random() {
        "a Prince?"
    } else {
        "a King?"
    }
}

print(makeSentence4())

类似地，我们可以通过向我们的构建器类型添加一个 buildArray() 方法来添加对循环的支持：

@resultBuilder
struct ComplexStringBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: "\n")
    }

    static func buildEither(first component: String) -> String {
        return component
    }

    static func buildEither(second component: String) -> String {
        return component
    }

    static func buildArray(_ components: [String]) -> String {
        components.joined(separator: "\n")
    }
}

现在我们可以使用 for 循环了：

@ComplexStringBuilder func countDown() -> String {
    for i in (0...10).reversed() {
        "\(i)…"
    }

    "Lift off!"
}

print(countDown())

感觉就像魔术一样，因为结果构建器系统为我们完成几乎所有的工作，尽管我们的例子非常简单，但我希望您能体会到结果构建器带给 Swift 的卓越功能。

值得补充的是，Swift 5.4 扩展了结果生成器系统以支持放置在存储属性上的属性，该属性会自动调整结构的隐式成员式初始值设定项以应用结果生成器。

这对于使用结果构建器的自定义 SwiftUI 视图特别有用，例如以下示例：

struct CustomVStack<Content: View>: View {
    @ViewBuilder let content: Content

    var body: some View {
        VStack {
            // custom functionality here
            content
        }
    }
}

如果您想查看实际的结果生成器示例，请查看 GitHub 上的 Awesome Function Builders 存储库(https://github.com/carson-katri/awesome-function-builders)。

本地函数现在支持重载

SR-10069(https://bugs.swift.org/browse/SR-10069) 要求能够在本地上下文中重载函数，这实际上意味着现在可以重载嵌套函数，以便Swift可以根据所使用的类型选择要运行的函数。

例如，如果我们要制作一些简单的 cookie，则可以编写如下代码：

struct Butter { }
struct Flour { }
struct Sugar { }

func makeCookies() {
    func add(item: Butter) {
        print("Adding butter…")
    }

    func add(item: Flour) {
        print("Adding flour…")
    }

    func add(item: Sugar) {
        print("Adding sugar…")
    }

    add(item: Butter())
    add(item: Flour())
    add(item: Sugar())
}

在 Swift 5.4 之前，只有在未嵌套在 makeCookies() 中的情况下，才可以重载这三个 add() 方法，但是从 Swift 5.4 开始，在这种情况下也支持函数重载。

现在支持局部变量的属性包装器

属性包装器最初是在 Swift 5.1 中引入的，它是一种通过简单，可重复使用的方式将附加功能附加到属性的方法，但是在 Swift 5.4 中，它们的行为得到扩展以支持将其用作函数中的局部变量。

例如，我们可以创建一个属性包装器，以确保其值永远不会低于零：

@propertyWrapper struct NonNegative<T: Numeric & Comparable> {
    var value: T

    var wrappedValue: T {
        get { value }

        set {
            if newValue < 0 {
                value = 0
            } else {
                value = newValue
            }
        }
    }

    init(wrappedValue: T) {
        if wrappedValue < 0 {
            self.value = 0
        } else {
            self.value = wrappedValue
        }
    }
}

从 Swift 5.4 起，我们可以在常规函数中使用该属性包装器，而不仅仅是将其附加到属性上。例如，我们可能编写了一款游戏，玩家可以得或失，但得分不得低于0：

func playGame() {
    @NonNegative var score = 0

    // player was correct
    score += 4

    // player was correct again
    score += 8

    // player got one wrong
    score -= 15

    // player got another one wrong
    score -= 16

    print(score)
}

包现在可以声明可执行目标

SE-0294(https://github.com/apple/swift-evolution/blob/main/proposals/0294-package-executable-targets.md) 使用 Swift Package Manager 为应用程序添加了新的目标选项，从而使我们可以显式声明可执行目标。

对于想使用 SE-0281(https://github.com/apple/swift-evolution/blob/main/proposals/0281-main-attribute.md)（使用@main标记程序入口点）的人们来说，这一点尤其重要，因为它在 Swift Package Manager 中无法很好地发挥作用-它将始终查找 main.swift 文件。

进行此更改后，我们现在可以删除 main.swift 并使用 @main 代替。注意：必须在Package.swift文件中指定 // swift-tools-version:5.4 才能获得此新功能。

本文由哈喽比特于3年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/p6oeWwcgJJFqP2NgYaJXYw