Swift 6.4 发布：iOS开发者值得关注的新特性

Swift 6.4 于 2026 年 9 月 15 日正式发布。这次更新除了语法上的改进，还涉及性能优化、构建工具和底层编程能力的提升。

它延续了 Swift 近年来的发展方向：让 Swift 走出传统的 Apple 应用开发场景，同时让底层编程更安全，让上层业务代码更容易维护。

这次更新覆盖了 Swift Package Manager、concurrency (并发)、subprocess execution (子进程执行)、C/C++ 互操作、Java 互操作、WebAssembly、Embedded Swift、Swift Testing、debugging，以及memory-efficient collections(更节省内存的集合类型)。

对 iOS 开发者来说，有些变化乍看并不起眼。但如果你在开发大型线上应用、SDK、后端服务，或者对性能比较敏感的模块，其中不少改进就很值得留意。

下面来看看这些变化具体能解决什么问题。

1. 可选的 `some` 和 `any` 类型，写起来更清爽了

随着不透明类型和存在类型逐渐成为现代 Swift 开发的常用工具，some 和 any 这两个关键字也越来越重要。

以前，要表示可选的不透明类型，需要这样写：

swift 复制代码

(some Rocket)?

Swift 6.4 支持更简洁的写法：

swift 复制代码

some Rocket?

existential types（可选的存在类型）也支持类似的简化写法。

这是一项不大的语法改进，但对于复杂的泛型代码和面向协议的代码，确实能提升可读性。

例如：

swift 复制代码

protocol DataProvider {
    associatedtype Output

    func load() async throws -> Output
}

struct UserProvider: DataProvider {
    func load() async throws -> User {
        User(id: 1, name: "Gaurav")
    }
}

func makeProvider() -> some DataProvider? {
    UserProvider()
}

它不会直接给应用增加什么新能力，但能减少高级类型写法中的括号，让代码更容易看懂。

2. `defer` 中可以执行异步代码了

这是 Swift 6.4 中很多人喜欢的一项改进。

Swift 开发者经常使用 defer 做收尾和资源清理：

swift 复制代码

func process() {
    let resource = acquireResource()

    defer {
        releaseResource(resource)
    }
    // 执行业务逻辑......
}

但清理操作并不总是同步的。

比如，处理文件结束后，需要通过异步调用上报埋点数据：

swift 复制代码

func processFile(at url: URL) async throws {
    let handle = try FileHandle(forReadingFrom: url)

    defer {
        await flushMetrics(for: url)
        try? handle.close()
    }
    try await processContents(of: handle)
}

Swift 6.4 允许在异步上下文中的 defer 里执行异步操作，让那些可能需要挂起的清理逻辑也能放在这里。

常见的使用场景包括：

网络操作的收尾
数据库操作
异步日志记录
资源管理
文件处理
埋点上报
基于 Actor 的服务

3. 用 `withTaskCancellationShield` 保护关键清理操作

这是另一项在实际项目中很有价值的并发改进。

假设任务在执行清理逻辑时被取消了。结构化并发中的取消通常会向子任务传播，而清理逻辑中的异步调用也可能响应取消。

但有些收尾工作，我们确实需要让它执行完。

Swift 6.4 引入了：

swift 复制代码

withTaskCancellationShield

例如：

swift 复制代码

defer {
    await withTaskCancellationShield {
        await flushMetrics(for: url)
        try? handle.close()
    }
}

它的核心思路很直观：

外层任务可以被取消，但关键清理代码可以屏蔽来自外层任务的取消。

比如，一个任务的执行流程可能是这样：

text 复制代码

Task
 ├── Download (下载)
 ├── Process (处理)
 └── Cleanup (清理)
      ├── Flush metrics (上报指标)
      ├── Save state (保存状态)
      └── Close resources (关闭资源)

如果没有保护，响应取消的操作可能让关键清理步骤提前结束。有了 cancellation shield，就可以明确标出需要保护的代码范围。

对于必须完成收尾工作的代码场景，这项能力尤其有用。

4. Swift Package Manager 的构建系统迎来重要变化

如果你平时主要写 SwiftUI 页面，这项更新可能没那么显眼。但对于维护大型项目的团队，它很重要。

Swift 6.4 将 Swift Build 设为 Swift Package Manager 的默认构建系统。

目标是在以下平台上提供更统一的构建体验：

macOS
Linux
Windows

也就是说，Swift 正在统一跨平台构建所依赖的基础设施。

Package 仍然可以使用常规的配置方式：

swift 复制代码

// Package.swift
let package = Package(
    name: "NetworkingKit",
    products: [
        .library(
            name: "NetworkingKit",
            targets: ["NetworkingKit"]
        )
    ],
    targets: [
        .target(
            name: "NetworkingKit"
        )
    ]
)

变化主要发生在底层构建机制，而不是 Package.swift 的语法上。

对于开发跨平台 Swift 库的团队，这是值得关注的一步。

5. Subprocess 正式进入 1.0

Swift 6.4 发布时，Subprocess 库也迎来了 1.0 版本。

它提供了跨平台的 Swift API，用于启动其他程序，并与这些程序交互。

例如：

swift 复制代码

let result = try await Subprocess.run(
    .name("ls"),
    arguments: ["-la"],
    output: .string(limit: 4096)
)
print(result.standardOutput)

以前，执行外部进程往往需要使用平台专属 API，或者借助第三方封装。现在有了一套基于 Swift 并发模型、更加统一的方案。

它适合用在：

CLI 工具
Developer tools (开发工具)
Build systems (构建系统)
Automation (自动化任务)
Server applications (服务端应用)
Local utilities (本地实用工具)

比如，开发一个 Swift 命令行应用，需要调用这些外部程序：

text 复制代码

git
ffmpeg
python
curl
docker
自定义可执行程序等

现在就可以通过 Swift 的并发模型来管理这些进程及其交互。

6. 借助 `Span`，Swift 与 C++ 的互操作更顺畅了

Swift 的互操作能力还在持续增强。

这次很值得关注的一点，是 C++ 的：

cpp 复制代码

std::span

与 Swift 的：

swift 复制代码

Span

可以在 C++ 互操作边界上直接桥接。

这有什么用？假设某个 C++ API 接收这样的参数：

cpp 复制代码

void process(std::span<const uint8_t> data);

Swift 侧就可以使用对应的 Span，省去手动处理"裸指针 + 元素数量"的转换代码。

可以这样理解：

text 复制代码

Swift Span
     ↓
C++ std::span
     ↓
C++ processing (处理逻辑)
     ↓
Swift Span

这样能减少跨语言调用时的衔接代码。

对于以下场景尤其有价值：

Game engines (游戏引擎)
Computer vision (计算机视觉)
Audio processing (音频处理)
Hardware SDKs (硬件 SDK)
现有 C++ 库的接入
对性能敏感的框架

Swift 的 C++ 互操作仍在发展中，而 Swift 6.4 又向实际工程应用推进了一步。

7. Java 互操作继续完善

Swift 的互操作能力并不局限于 C 和 C++。

Swift 6.4 也扩展了 Swift/Java 互操作项目的能力，涉及：

Async functions (异步函数)
Throwing functions (可抛出错误的函数)
Protocol wrappers (协议包装器)
Callback wrappers (回调包装器)
Runnable 映射
Variadic parameters (可变参数)
Java record 类型

对于 Swift 与 Java/Kotlin 共存的项目，这些改进很值得关注。

从更大的范围看，可以这样理解：

text 复制代码

              Swift
                |
       -------------------
       |        |        |
      C/C++    Java    Kotlin
       |
    Systems (系统级代码)

Swift 正在逐渐具备与 Apple 传统平台之外的技术生态协作的能力。

8. Swift 在浏览器中的桥接性能提升了

Swift 对 WebAssembly 的支持已经发展了一段时间。

Swift 6.4 提升了 JavaScriptKit 的 WebAssembly 桥接性能。根据 Swift 团队的介绍，安全桥接相比之前的动态桥接方式，最高可快 40 倍。

这里需要注意：这不代表所有 Swift WebAssembly 应用都会自动快 40 倍。

提升针对的是桥接路径。应用整体能获得多大收益，要看它在 JavaScript 与 Wasm 之间进行了多少交互。

即便如此，这仍是一项重要改进。整体架构大致如下：

text 复制代码

Browser (浏览器)
   |
JavaScript
   |
JavaScriptKit
   |
WebAssembly
   |
Swift

另外，Swift 6.4 的 Wasm SDK 可以直接从 Swift.org 获取，降低了尝试用 Swift 开发浏览器应用的门槛。

9. Swift 在 Android 上的支持越来越成熟

对于同时关注 iOS 和 Android 开发的人来说，这项更新很有吸引力。

Swift 6.4 改进了 Android 支持。Swift SDK for Android 现在基于 Android NDK 30 构建，Swift Build 也能在 SwiftPM 中直接支持 Android。

这样一来，SwiftPM 工作流程中就不再需要额外的安装后脚本。

整体方向可以这样理解：

text 复制代码

             Swift
          /    |    \
       Apple  Linux  Android
                      |
                    NDK 30

Swift 并不是要取代 Kotlin 在 Android 开发中的位置。但随着互操作能力和工具链不断完善，在共享原生组件、库，以及一些特定用途的应用中，Swift 变得更值得考虑了。

10. Embedded Swift 的能力更丰富了

Embedded Swift 面向微控制器、嵌入式系统等资源受限的环境。

Swift 6.4 进一步扩展了它的能力，其中一个值得关注的改进，是支持这类存在类型：

swift 复制代码

any Protocol

同时，它也具备了更丰富的错误处理能力。

例如：

swift 复制代码

protocol Sensor {
    func read() throws -> Double
}

let sensors: [any Sensor] = [
    TemperatureSensor(),
    PressureSensor()
]

这样，在 Embedded Swift 中表达包含不同具体类型的集合，以及使用协议，就更方便了。

Swift 6.4 还引入了 EmbeddedRestrictions 警告，可以为整个 target 启用：

swift 复制代码

.target(
    name: "FirmwareCore",
    swiftSettings: [
        .treatWarning(
            "EmbeddedRestrictions",
            as: .warning
        )
    ]
)

这也说明，Swift 正在适配越来越多样的运行环境。

11. 不可复制类型在实际开发中更好用了

从性能角度看，这部分是 Swift 6.4 很值得关注的变化。

Swift 近年来一直在投入以下方向：

所有权（Ownership）
借用（Borrowing）
不可复制类型（Non-copyable types）
内存安全 (Memory safety)

Swift 6.4 对 UniqueArray、UniqueBox、Ref、MutableRef 和 Iterable 等类型与协议带来了改进。

来看一个较大的数据结构：

swift 复制代码

struct LargeBuffer {
    var data: [UInt8]
}

传统的值语义可能涉及复制或写时复制（Copy-on-write）机制。

Swift 6.4 提供了一些工具，适合需要更精细地控制所有权和复制行为的场景。

例如，UniqueArray 可以存储不可复制的元素，同时避免普通 Array 在写时复制时可能产生的额外分配。

可以这样理解：

text 复制代码

传统 Array

Array
  ↓
Copy-on-write (写时复制)
  ↓
Possible allocation (可能触发新的内存分配)


UniqueArray
Unique ownership (独占所有权)
  ↓
直接管理存储
  ↓
减少不必要的内存分配

目标是保留 Swift 的安全模型，同时提供更接近底层的性能控制能力：

在维持 Swift 内存安全保证的前提下，获得更好的底层性能。

12. 新的 `Iterable` 协议

Swift 开发者对这个协议应该都很熟悉：

swift 复制代码

Sequence

Swift 6.4 引入了：

swift 复制代码

Iterable

它的关键在于：遍历时可以借用元素，而不必在需要避免复制的场景中复制元素。

从使用方式上看，仍然可以理解为这样的遍历：

swift 复制代码

for element in collection {
    process(element)
}

底层则可以采用以借用为基础的语义。

当元素具备以下特点时，这项能力尤其有用：

Large (体积较大)
Non-copyable (不可复制)
Expensive to duplicate (复制成本较高)
Backed by low-level memory (直接关联底层内存)

Swift 对 Iterable 的定位，是在遍历时借用元素的能力上，进一步扩展 Sequence 所能支持的范围。

13. 更安全的原始内存操作

编写底层 Swift 代码时，经常需要直接处理原始内存。过去，这往往意味着要使用标记为 unsafe 的 API。

Swift 6.4 引入了：

swift 复制代码

withTemporaryAllocation

它提供临时工作缓冲区，并自动完成初始化和清理。

此外，RawSpan 及相关类型也增加了安全的内存加载 API。

这背后的方向很值得关注。过去，我们经常面对这样的路径：

text 复制代码

Performance (追求性能)
   ↓
使用 Unsafe API
   ↓
由开发者保证正确性

而 Swift 正在提供更多这样的选择：

text 复制代码

Performance (追求性能)
   ↓
Safe ownership/memory APIs (使用安全的所有权与内存 API)
   ↓
由编译器约束并提供保证

这是现代 Swift 一个很重要的发展主题。

14. Swift Testing 更容易逐步接入了

Swift 6.4 改善了 XCTest 与 Swift Testing 之间的迁移体验。

现在可以在 Swift Testing 测试中安全地使用：

swift 复制代码

XCTAssert

也可以在 XCTest 测试中使用：

swift 复制代码

#expect

例如：

swift 复制代码

@Test
func userNameIsCorrect() {
    let user = User(
        id: 1,
        name: "Gaurav"
    )
    #expect(user.name == "Gaurav")
}

这意味着，不必一次性迁移整个测试套件。对于代码量较大的线上项目，逐步采用 Swift Testing 就更容易落地了。

Swift 6.4 还改进了测试重复执行和附件相关的能力。

15. 用 `@diagnose` 更精细地控制编译器诊断

另一项开发体验上的改进，是可以在源码层面控制编译器警告。

Swift 6.4 引入了：

swift 复制代码

@diagnose

开发者可以直接在源码中控制警告行为。

维护大型项目时，如果需要更精确地管理编译器诊断，这项能力会很有帮助。

这样，一部分诊断配置就能放在相关代码附近，而不必全部依赖外部构建配置。

16. 用模块选择器解决命名冲突

假设导入的两个模块都定义了同名类型：

swift 复制代码

ModuleA.CommonThing
ModuleB.CommonThing

以前，处理这类命名冲突有时会比较麻烦。

Swift 6.4 引入了使用以下符号的模块选择器：

swift 复制代码

::

它可以明确指定要引用哪个模块，例如：

swift 复制代码

ModuleA::CommonThing

这项功能不大，但维护过依赖较多的大型应用的人应该都知道：命名冲突有时确实很让人头疼。

17. Swift Package Manager 可以生成 SBOM 了

软件安全，以及对软件供应链的掌握，正在变得越来越重要。

Swift 6.4 为 Swift Package Manager 增加了软件物料清单（Software Bill of Materials，SBOM）支持。

可以生成以下格式的 SBOM 文档：

text 复制代码

SPDX

或者：

text 复制代码

CycloneDX

对于企业项目，这项能力很实用，因为团队越来越需要了解：

text 复制代码

Application (应用)
   ↓
Dependencies (直接依赖)
   ↓
Transitive dependencies (间接依赖)
   ↓
Versions (版本信息)
   ↓
Security/compliance (安全与合规情况)

SBOM 支持让 Swift 的 Package 生态更符合现代软件供应链管理的要求。

18. Debugging 调试体验进一步改善

Swift 6.4 完成了一项跨越多个版本的改进：重新完善调试信息中 Swift 模块的跟踪方式。

LLDB 现在可以通过更精确的依赖跟踪加载模块，而不是依靠可能存在歧义的模块名称查找。

Swift 团队还表示，由于不再需要将二进制 Swift 模块嵌入调试产物，一些环境下的调试产物体积也会减小。

对开发者来说，好处很直接：

text 复制代码

Breakpoint (命中断点)
   ↓
LLDB
   ↓
找到正确的 Swift 模块
   ↓
获得更好的调试体验

这类改进，往往在大型项目中才更容易体会到它的价值。

Swift 6.4 对 iOS 开发者意味着什么？

如果你主要做 iOS 开发，看完这份清单可能会想：

这些变化到底有多少会影响我的日常工作？

其实有不少。最值得优先关注的是下面几个方向。

Concurrency(并发)

swift 复制代码

defer {
    await withTaskCancellationShield {
        await cleanup()
    }
}

这能让异步代码中的资源清理更稳妥。

Swift Testing

swift 复制代码

@Test
func testSomething() {
    #expect(result == expected)
}

XCTest 与 Swift Testing 之间的逐步迁移会更方便。

Package 管理

SwiftPM 拥有了更统一的构建基础设施，也增加了 SBOM 支持。

Performance(性能)

Ownership(所有权)、borrowing(借用)、UniqueArray、Iterable 及相关改进，为性能敏感的代码提供了更多工具。

互操作

C++ std::span 与 Swift Span 的直接桥接，减少了跨语言调用时的衔接工作。

从更大的范围看 Swift 的发展

对开发者来说，Swift 6.4 最值得关注的，并不是某一项语法变化，而是它的发展方向。

Swift 正在覆盖更多领域：

text 复制代码

              Swift
                |
    --------------------------------
    |       |       |       |      |
   iOS    Server   Linux   Wasm  Embedded
    |                       |
   macOS                   浏览器(Browser)
    |
 Android

一方面，它在拓展应用场景；另一方面，它也在深入系统编程领域。

与此同时，Swift 持续投入的方向包括：

Memory safety(内存安全)
Concurrency safety (并发安全)
Ownership(所有权)
Performance(性能)
Interoperability(互操作)
Tooling(工具链)
Cross-platform development(跨平台开发)

Swift 6 把并发代码的数据竞争安全作为重点。Swift 6.4 延续了这一方向，进一步朝着更安全、能力更完整的系统编程语言发展。

现在应该开始使用 Swift 6.4 吗？

如果准备启动一个新的 Swift 项目，Swift 6.4 值得尝试。

如果是已经上线的应用，升级就应该按一次工程迁移来处理。实际工作远不止把版本从 Swift 6.x 改成 Swift 6.4：

text 复制代码

Swift 6.x
   ↓
Swift 6.4

建议按下面的流程推进：

text 复制代码

1. 升级工具链
        ↓
2. 构建现有项目
        ↓
3. 运行单元测试和 UI 测试
        ↓
4. 检查并发相关诊断
        ↓
5. 检查第三方依赖
        ↓
6. 测量构建耗时
        ↓
7. 测量运行时性能
        ↓
8. 分阶段推广

尤其是大型 iOS 项目，在把升级后的工具链设为整个团队的默认配置之前，应先确认依赖兼容性，以及 CI/CD 环境对工具链的支持情况。

最后

我是小侯爷。在帝都北京工作，喜欢iOS、Flutter、Android、React。最近打算跳槽，正在找新的工作，欢迎大家给内推哦。如果读完觉得有收获的话，记得点赞哦。

Swift 6.4 发布：iOS开发者值得关注的新特性

1. 可选的 some 和 any 类型，写起来更清爽了

2. defer 中可以执行异步代码了

3. 用 withTaskCancellationShield 保护关键清理操作

4. Swift Package Manager 的构建系统迎来重要变化

5. Subprocess 正式进入 1.0

6. 借助 Span，Swift 与 C++ 的互操作更顺畅了

7. Java 互操作继续完善

8. Swift 在浏览器中的桥接性能提升了

9. Swift 在 Android 上的支持越来越成熟

10. Embedded Swift 的能力更丰富了

11. 不可复制类型在实际开发中更好用了

12. 新的 Iterable 协议

13. 更安全的原始内存操作

14. Swift Testing 更容易逐步接入了

15. 用 @diagnose 更精细地控制编译器诊断

16. 用模块选择器解决命名冲突

17. Swift Package Manager 可以生成 SBOM 了

18. Debugging 调试体验进一步改善

Swift 6.4 对 iOS 开发者意味着什么？

Concurrency(并发)

Swift Testing

Package 管理

Performance(性能)

互操作

从更大的范围看 Swift 的发展

现在应该开始使用 Swift 6.4 吗？

最后

1. 可选的 `some` 和 `any` 类型，写起来更清爽了

2. `defer` 中可以执行异步代码了

3. 用 `withTaskCancellationShield` 保护关键清理操作

6. 借助 `Span`，Swift 与 C++ 的互操作更顺畅了

12. 新的 `Iterable` 协议

15. 用 `@diagnose` 更精细地控制编译器诊断