0Pricing
Swift Academy · 课时

惰性与即时求值的权衡

了解惰性求值何时有益或有害。

惰性与即时求值的权衡 是 CoddyKit 上的免费 Swift Academy 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Swift Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Swift Academy 课程共包含 4 节课。

没有免费的午餐

惰性并不总是更快。它用每次访问的开销换取前期分配，并改变副作用发生的时机。了解这些权衡后，您就能做出正确选择。

惰性更优：部分消费

只需要使用巨大转换结果的一部分 — 惰性计算会跳过其余部分：

let data = Array(1...1_000_000)
let top = data.lazy.map { $0 * 2 }.prefix(3)
print(Array(top))  // [2, 4, 6]  -- 999,997 transforms skipped

立即求值更优：完整复用

如果要多次迭代结果，立即求值只计算一次；惰性计算则会在每次遍历时重新计算：

let doubled = [1, 2, 3].map { $0 * 2 }  // computed once
print(doubled.reduce(0, +))  // 12
print(doubled.max()!)        // 6  -- no recompute

惰性会重新计算

同一个惰性视图会在每次迭代时再次执行这些工作：

var work = 0
let view = [1, 2, 3].lazy.map { (n: Int) -> Int in work += 1; return n }
_ = view.reduce(0, +)
_ = view.max()
print(work)  // 6  -- transformed twice

每个元素的开销

每个惰性步骤都会将序列包装在另一种类型中，并通过闭包逐个元素调用。对于很小的数组，这种开销可能超过节省下来的分配成本。

小数组使用立即求值即可

对于少量且会被完整消费的元素，优先使用普通的立即求值 — 这样更简单，而且分配成本微不足道：

let nums = [3, 1, 2]
let sorted = nums.map { $0 + 1 }.sorted()
print(sorted)  // [2, 3, 4]

副作用的时机不同

使用惰性计算时，闭包主体的运行时间晚于定义它的代码行。请避免依赖惰性转换中的副作用：

var log: [Int] = []
let v = [1, 2].lazy.map { (n: Int) -> Int in log.append(n); return n }
print(log)        // []  -- nothing ran yet
_ = Array(v)
print(log)        // [1, 2]

会强制立即求值的操作

有些操作无论如何都必须读取整个序列，因此惰性计算在这些情况下没有优势：

let nums = Array(1...10)
print(nums.lazy.map { $0 * 2 }.sorted())  // sorted must see all -> [2,4,...,20]
print(nums.lazy.map { $0 }.count)         // count walks everything

惰性与 contains

对于大型输入，contains(where:) 等短路操作可以从惰性计算中受益：

let big = Array(1...1_000_000)
let found = big.lazy.map { $0 * 2 }.contains { $0 == 8 }
print(found)  // true  -- stops at element 4

决策检查清单

在以下情况下使用惰性计算：源很大，并且您只保留其中一部分（prefix / first / contains），同时只迭代一次。在以下情况下使用立即求值：数组很小、您会复用结果，或者可读性比微优化更重要。

let huge = Array(1...100_000)
let first = huge.lazy.filter { $0 % 9973 == 0 }.first
print(first!)  // 9973

进行测量，不要猜测

对性能的直觉往往并不准确。性能确实重要时，请先使用现实数据对两个版本进行基准测试，再决定是否采用惰性计算。

let nums = Array(1...50)
let eager = nums.filter { $0 > 25 }.count
let lazyC = nums.lazy.filter { $0 > 25 }.count
print(eager == lazyC)  // true -- same answer, profile for speed

快速检查

什么时候选择立即求值会比惰性计算更好？

回顾

您已经了解了这些权衡：

  • 对于大型源、部分消费且只遍历一次的情况，惰性计算更有优势
  • 对于小数组和会复用的结果，立即求值更有优势（惰性计算会重新计算）
  • 惰性转换中的副作用会延后运行 — 请避免依赖它们
  • 优化前先进行测量

下一步：构建自定义惰性序列。

常见问题解答

「惰性与即时求值的权衡」课时是免费的吗？

是的 — 「惰性与即时求值的权衡」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Swift Academy 课程的其余内容，请升级到 CoddyKit PRO。 Swift Academy 课程共包含 4 节课。

「惰性与即时求值的权衡」这节课中我会学到什么？

了解惰性求值何时有益或有害。 你通过在浏览器中直接运行的动手代码来练习 Swift Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Swift Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Swift Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「惰性与即时求值的权衡」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Swift Academy 课中编写并运行代码吗？

能。每节 Swift Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. lazy 属性
  2. 惰性 map 与 filter
  3. 惰性与即时求值的权衡
  4. 构建自定义惰性序列
← 返回 Swift Academy