{"data":{"post":{"title":"再探 Swift 宏 - 优势与本质","subtitle":"","isPublished":true,"createdTime":"2023-08-08T00:00:00.000Z","lastModifiedTime":null,"license":null,"tags":["Swift","宏"],"category":"编程","file":{"childMdx":{"excerpt":"通过 WWDC 2023，我们了解到 Swift 宏的目标是： 消除重复代码 让繁琐的事情变得简单 以软件包的形式与其他开发者分享 然而，这些目标并不是 Swift 宏所独有的。对于 Swift…","code":{"body":"function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\nconst layoutProps = {};\nreturn class MDXContent extends React.Component {\n constructor(props) {\n super(props);\n this.layout = null;\n }\n\n render() {\n const _this$props = this.props,\n {\n components\n } = _this$props,\n props = _objectWithoutProperties(_this$props, [\"components\"]);\n\n return React.createElement(MDXTag, {\n name: \"wrapper\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `通过 WWDC 2023，我们了解到 Swift 宏的目标是：`), React.createElement(MDXTag, {\n name: \"ul\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `消除重复代码`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `让繁琐的事情变得简单`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `以软件包的形式与其他开发者分享`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，这些目标并不是 Swift 宏所独有的。对于 Swift 中的许多代码重用手段而言，这些都是共同的目标，如函数、类型和模块。可以说，所有高级编程语言都希望实现这些目标。Swift 宏必须在其他方面有所胜出；否则的话没必要存在。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `那么， Swift 宏到底擅长什么？`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `这个问题的答案至关重要。 Swift 宏独一无二的优势会决定它的本质：这可以指导我们创作有效的 Swift 宏、告诉我们在创作宏时的行为边界，并最终帮助我们产出良好设计的 Swift 宏。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `要理解这一点，我们首先需要理解 Swift 现有的代码重用手段解决了哪些问题以及它们的局限性。了解 Swift 宏的独特之处就在于这一探索过程。`), React.createElement(MDXTag, {\n name: \"h2\",\n components: components\n }, `现有代码重用手段解决了什么问题？`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `在 Swift 中，代码重用的方法将代码封装到不同层次的粒度中，从最细粒度的函数到最粗粒度的模块。这种设计为我们提供了一个层次化的工具集，帮助我们在每个层级上消除冗余代码。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，一个良好设计的代码重用手段不仅仅意味着消除不必要的复制粘贴，还要为混乱带来秩序。从高级编程语言开发者的角度来看，这种混乱通常来自于意外的变量名、函数名或类型名绑定结果以及意外的程序执行顺序。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `此外，现实世界中的代码重用中通常涉及各方提供的代码。这意味着对于编译语言而言，要复用的代码可能以不同的分发形式存在：源代码或预构建的库。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `让我们看看现有的 Swift 代码重用手段如何处理所有这些问题。`), React.createElement(MDXTag, {\n name: \"h3\",\n components: components\n }, `函数`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `在 Swift 中，函数是最细粒度的代码重用手段。程序员通过使用诸如 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `if ... else ...`), ` 语句、`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `while`), ` 循环、`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `for`), ` 循环和 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `return`), ` 语句等控制结构来组织执行流序列，以封装基础算法。在控制结构的代码块中声明的变量具有比外部声明的变量更高的绑定优先级。对此这有一段代码作为示例。每一条线表示一个名称绑定结果。`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `// 源文件根部声明的全局变量\nvar bar: Int = 0\n// ^\n// |\n// +---------------------------------------------------+\nfunc foo() { // |\n func getHexDescription(for index: Int) -> String { // |\n return \"0x\" + String(index, radix: 16) // |\n } // |\n for i in 0..<100 { // |\n // for 循环体内部声明的局部变量 |\n let bar = getHexDescription(for: i) // |\n// ^ |\n// | |\n// +--------- + |\n// | |\n print(\"bar = \\\\(bar)\") // |\n } // |\n// +-----------------------------------------------------+\n// |\n bar += 1\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `上述代码在我们的日常编程中已经变得再平常不过。然而，达成这一点并非易事。这个设计背后的理念被称为「结构化编程」，由以下几个关键原则定义：`), React.createElement(MDXTag, {\n name: \"ul\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `变量只能在控制结构的代码块内访问。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `控制结构可以用更具表达力的方式，例如使用 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `if ... else ...`), ` 而不仅仅是简单的 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `if`), ` 语句。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `可以通过更高级的控制结构消除 goto 语句。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `函数体内可以定义另一个函数。`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `最早的高级编程语言 FORTRAN 并没有像我们今天所理解的那样采纳这些原则。之后整个计算机工业花费了几年时间来完善和整合这些概念。随后，「结构化编程」的设计理念对高级编程语言的设计和发展产生了重大影响。Swift 也采纳了「结构化编程」的设计理念，来让程序员能够构建健壮的函数。`), React.createElement(MDXTag, {\n name: \"h3\",\n components: components\n }, `类型`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `Swift 类型允许程序员将共享内部关系的数据和函数聚合在一起。与独立函数相比，这可以在更大的粒度上实现代码复用。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，仅仅将许多东西打包在一起中并不能消除复杂性。当访问在类型中声明的成员时，应存在与「结构化编程」中变量的访问规则类似的原则。这样我们才可以确保变量名/函数/类型名绑定的结果符合预期。否则，将会在不同类型之间引起无尽的命名冲突。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `另外，内部数据和实现也不应该在某个特定的范围外可以被访问到。这个范围可以是类型或源文件等。这样通过只向程序员公开必要的信息、阻止意外访问内部实现而产生的未定义行为，以及限定类型可以协作的范围，我们就可以减轻使用该类型的程序员的心智负担。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `Swift 类型通过以下方式解决了上述挑战：`), React.createElement(MDXTag, {\n name: \"ul\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `在类型定义块内可以访问类型成员，如变量和函数所声明的。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `引入点符号语法来访问类型块之外的成员。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `引入访问控制以保护类型中特定范围内的成员。`)), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `struct Foo {\n\n // \\`bar\\` 是私有的\n private var bar: Int\n\n func print() {\n // \\`bar\\` 仅可以在 \\`Foo\\` 的类型块中访问.\n print(bar)\n }\n\n}\n\nlet foo = Foo()\n// \\`print\\` 可以通过点语法访问\nfoo.print()\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `有了这些点，程序员可以通过泛化从 Swift 函数中学习到的「结构化编程」原则，在与类型打交道的过程中直观地预测变量名/函数/类型名绑定结果，并带入其他具有点语法和访问控制的语言中获得的经验。`), React.createElement(MDXTag, {\n name: \"h3\",\n components: components\n }, `模块`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `从前面的部分可以看出，当数据和函数共享内部关系时，Swift 是如何通过类型加强代码的可重用性的。当类型也共享这些关系时，我们如何进一步提高代码的可重用性呢？`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `一个直观的答案是进一步将类型、数据和函数封装成更大粒度的抽象。在 Swift 中，这就是模块所做的事情。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，在 Swift 中，模块不仅仅是另一个代码的聚合体。就像类型系统一样，一个朴素设计的模块系统也可能引入模块之间的命名冲突，并公开不必要的实现细节。通过进一步泛化我们从类型中学到的避免类似问题的方法，Swift 也避免了这些问题。这些方法具体是：`), React.createElement(MDXTag, {\n name: \"ul\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `模块成员，如变量、函数和类型，可以在模块内部访问。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `当不同模块中的名称冲突时，引入点号表示法来访问模块外部的成员。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `引入访问控制来保护模块内部特定范围的成员。`)), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `// 在 Foo 模块中\n\nprivate var name = \"foo\"\n\npublic var version: String {\n return \"1.0\"\n}\n\npublic func foo() {\n print(name)\n}\n\n// 在 Bar 模块中\n\nprivate var name = \"bar\"\n\npublic var version: String {\n return \"2.0\"\n}\n\npublic func bar() {\n print(name)\n}\n\n// 在 app 中\n\nimport Foo\nimport Bar\n\nprint(Foo.version)\nfoo()\nbar()\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `除此之外，模块也是分发代码的一种方式。由于人们可以将自己的代码分发为源代码或预构建的二进制文件，Swift 编译器在实现模块系统时会考虑这一点。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"figure\",\n components: components,\n parentName: \"p\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"a\",\n components: components,\n parentName: \"figure\",\n props: {\n \"href\": \"/static/416ff74a809bcc6145b45758e39ca968/17031/potential-different-forms-of-distribution-for-modules.png\"\n }\n }, React.createElement(MDXTag, {\n name: \"img\",\n components: components,\n parentName: \"a\",\n props: {\n \"title\": \"模块的潜在不同分发形式\",\n \"alt\": \"模块的潜在不同分发形式\",\n \"src\": \"/static/416ff74a809bcc6145b45758e39ca968/17031/potential-different-forms-of-distribution-for-modules.png\",\n \"srcSet\": [\"/static/416ff74a809bcc6145b45758e39ca968/17031/potential-different-forms-of-distribution-for-modules.png 1x\", \"/static/7d40b5fa4a7a7fe5197fa8858a5663be/6115b/potential-different-forms-of-distribution-for-modules%402x.png 2x\", \"/static/2d9e9773c1f4a8b1c661d1fbbafd9a16/907ec/potential-different-forms-of-distribution-for-modules%403x.png 3x\"],\n \"loading\": \"lazy\"\n }\n })), `\n `, React.createElement(MDXTag, {\n name: \"figcaption\",\n components: components,\n parentName: \"figure\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"span\",\n components: components,\n parentName: \"figcaption\"\n }, `\n 模块的潜在不同分发形式\n `), `\n `))), React.createElement(MDXTag, {\n name: \"h3\",\n components: components\n }, `总结`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `通过回顾 Swift 中现有的代码重用手段，我们可以发现它们倾向于将较小的抽象聚合成更大的抽象，并采用特定的保护机制来确保合理的名字查找结果和预期的程序执行流程。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"figure\",\n components: components,\n parentName: \"p\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"a\",\n components: components,\n parentName: \"figure\",\n props: {\n \"href\": \"/static/d31662b2d7d62db68d3e1872c9af98e3/61cee/established-trends-of-modules-types-and-functions.png\"\n }\n }, React.createElement(MDXTag, {\n name: \"img\",\n components: components,\n parentName: \"a\",\n props: {\n \"title\": \"模块/类型和函数的设计倾向\",\n \"alt\": \"模块/类型和函数的设计倾向\",\n \"src\": \"/static/d31662b2d7d62db68d3e1872c9af98e3/61cee/established-trends-of-modules-types-and-functions.png\",\n \"srcSet\": [\"/static/d31662b2d7d62db68d3e1872c9af98e3/61cee/established-trends-of-modules-types-and-functions.png 1x\", \"/static/18f07f018ddb8ba0a3a23bdebeae0e24/ab540/established-trends-of-modules-types-and-functions%402x.png 2x\", \"/static/4da6c4d4c999ca77da47da20856c1574/0095f/established-trends-of-modules-types-and-functions%403x.png 3x\"],\n \"loading\": \"lazy\"\n }\n })), `\n `, React.createElement(MDXTag, {\n name: \"figcaption\",\n components: components,\n parentName: \"figure\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"span\",\n components: components,\n parentName: \"figcaption\"\n }, `\n 模块/类型和函数的设计倾向\n `), `\n `))), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，正是这些优势限制了它们的功能。出于这些保护机制，仍然有一些编程概念无法封装，因为有些概念要求我们放弃这种保护机制。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `为了进一步提高语言的代码可重用性，我们不能再遵循这些现有的代码重用手段的设计倾向。`), React.createElement(MDXTag, {\n name: \"h2\",\n components: components\n }, `Swift 宏在哪些方面表现出色？`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `相反，Swift 宏通过采用不同的设计理念来提高语言的代码可重用性。为了帮助你全面了解这些设计理念，我想通过一些典型的示例向你展示 Swift 宏的本质。`), React.createElement(MDXTag, {\n name: \"h3\",\n components: components\n }, `编译时转换和验证`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `设计软件如 Figma 和 Sketch 使用 6 个十六进制数字表示 RGB 颜色。开发者经常通过扩展颜色的类型，以便直接从设计软件中复制和粘贴 RGB 值，以供在 Swift 中使用：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `import SwiftUI\n\n// 颜色类型扩展\nextension Color {\n\n public init(_ hex: UInt)\n\n}\n\n// 使用例子\nColor(0xFFEEAA)\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `但是我们如何验证复制粘贴的值是否是有效的 RGB 颜色呢？复制粘贴的动作不能确保结果的正确性。下面的代码片段展示了一个可能的复制粘贴错误。`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `// 无效颜色. 只有 5 个十六进制码\nColor(0xFFEEA)\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，由于 Swift 宏通过对其参数进行语法变形来生成新代码，或者说「展开宏」，我们可以在此变形期间集成语法检查。这使得可以对 6 位十六进制 RGB 颜色「字面量」进行编译时验证。`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `#Color(0xFFEEAA) // 可以编译\n// #Color 宏展开开始\nSwiftUI.Color(red: 1, green: 0.93, blue: 0.67)\n// #Color 宏展开结束\n#Color(0xFFEEA) // 无效 RGB，无法编译\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"figure\",\n components: components,\n parentName: \"p\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"a\",\n components: components,\n parentName: \"figure\",\n props: {\n \"href\": \"/static/c138354b0751fd91824926ea476ffb16/08d94/invalid-rgb-literal.webp\"\n }\n }, React.createElement(MDXTag, {\n name: \"picture\",\n components: components,\n parentName: \"a\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"source\",\n components: components,\n parentName: \"picture\",\n props: {\n \"src\": \"/static/c138354b0751fd91824926ea476ffb16/0cc25/invalid-rgb-literal.png\",\n \"srcSet\": [\"/static/c138354b0751fd91824926ea476ffb16/5116e/invalid-rgb-literal.png 178w\", \"/static/c138354b0751fd91824926ea476ffb16/92f55/invalid-rgb-literal.png 356w\", \"/static/c138354b0751fd91824926ea476ffb16/0cc25/invalid-rgb-literal.png 712w\", \"/static/c138354b0751fd91824926ea476ffb16/7ae06/invalid-rgb-literal.png 1068w\", \"/static/c138354b0751fd91824926ea476ffb16/eee47/invalid-rgb-literal.png 1424w\", \"/static/c138354b0751fd91824926ea476ffb16/38407/invalid-rgb-literal.png 2136w\", \"/static/c138354b0751fd91824926ea476ffb16/240a0/invalid-rgb-literal.png 2144w\"],\n \"sizes\": \"(max-width: 712px) 100vw, 712px\"\n }\n }), React.createElement(MDXTag, {\n name: \"source\",\n components: components,\n parentName: \"picture\",\n props: {\n \"src\": \"/static/c138354b0751fd91824926ea476ffb16/690c8/invalid-rgb-literal.webp\",\n \"srcSet\": [\"/static/c138354b0751fd91824926ea476ffb16/25c8a/invalid-rgb-literal.webp 178w\", \"/static/c138354b0751fd91824926ea476ffb16/60698/invalid-rgb-literal.webp 356w\", \"/static/c138354b0751fd91824926ea476ffb16/690c8/invalid-rgb-literal.webp 712w\", \"/static/c138354b0751fd91824926ea476ffb16/d7e52/invalid-rgb-literal.webp 1068w\", \"/static/c138354b0751fd91824926ea476ffb16/456ef/invalid-rgb-literal.webp 1424w\", \"/static/c138354b0751fd91824926ea476ffb16/2a654/invalid-rgb-literal.webp 2136w\", \"/static/c138354b0751fd91824926ea476ffb16/08d94/invalid-rgb-literal.webp 2144w\"],\n \"sizes\": \"(max-width: 712px) 100vw, 712px\"\n }\n }), `\n `, React.createElement(MDXTag, {\n name: \"img\",\n components: components,\n parentName: \"picture\",\n props: {\n \"src\": \"/static/c138354b0751fd91824926ea476ffb16/08d94/invalid-rgb-literal.webp\",\n \"alt\": \"无效 RGB，无法编译\",\n \"title\": \"无效 RGB，无法编译\",\n \"width\": 712,\n \"height\": 313,\n \"loading\": \"lazy\"\n }\n }))), `\n `, React.createElement(MDXTag, {\n name: \"figcaption\",\n components: components,\n parentName: \"figure\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"span\",\n components: components,\n parentName: \"figcaption\"\n }, `\n 无效 RGB，无法编译\n `), `\n `))), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `通过这个例子，你也许已经获得了启发，可以去看看这种编译计算如何应用于其他种类的「字面量」。`), React.createElement(MDXTag, {\n name: \"h3\",\n components: components\n }, `提供超越函数的行为`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `在实践中，我们通常避免使用感叹号来强制解包可选值：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `func foo(_ bar: Int?) {\n print(bar!)\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `相反，我们更喜欢一种更安全的方法--使用 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `guard let ... else`), `：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `func foo(_ bar: Int?) {\n guard let bar else {\n return\n }\n print(bar)\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，这可能会很繁琐，尤其是当有多个可选参数时。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `鉴于程序员的天性，程序员们必然希望封装这个解包过程以便重用。不幸的是，由于「结构化编程」的缘故，函数保护了其内部执行流程免受内部函数的返回的影响，我们无法将这个 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `guard let ... else`), ` 封装在一个函数中--因为函数中的 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `return`), ` 语句无法使调用方函数退出。`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `func guard(_ value: T?) -> T {\n guard let value else {\n // 这个 return 无法使得 \\`foo\\` 也 return.\n // 此外，这个函数也无法通过编译\n return\n }\n return value\n}\n\nfunc foo(_ bar: Int?) {\n let bar = guard(bar)\n print(bar)\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `不过， Swift 宏为这种类型的封装提供了一种可行的方法。我们可以有一个名为 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `#unwrap`), ` 的宏，使用方法如下所示：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `func foo(_ bar: Int?) {\n #unwrap(bar) {\n print(bar)\n }\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `这可以被展开为：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `func foo(_ bar: Int?) {\n // #unwrap 宏展开开始\n guard let bar = bar else {\n return\n }\n print(bar)\n // #unwrap 宏展开结束\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `在上面的示例中，`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `#unwrap`), ` 宏的参数--`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `bar`), ` 和尾闭包，在编译器启动宏展开过程之前已经完成了类型检查。这意味着在宏展开之前，`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `print`), ` 内的尾闭包接收到的 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `bar`), ` 将绑定到 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `foo`), ` 函数的参数 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `_ bar: Int?`), `。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，一旦宏展开，由于展开过程本身可以被视为类似于复制粘贴的语法树替换，`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `print`), ` 现在使用的 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `bar`), ` 将绑定到由 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `guard let bar`), ` 语句声明的 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `bar`), `，与宏展开之前的类型检查结果无关。此外，此宏展开带来的 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `return`), ` 语句也可以影响应用点的控制流。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `该示例展示了由 freestanding Swift macro 展开而可能涉及到的`, React.createElement(MDXTag, {\n name: \"strong\",\n components: components,\n parentName: \"p\"\n }, `控制流操控`), `和`, React.createElement(MDXTag, {\n name: \"strong\",\n components: components,\n parentName: \"p\"\n }, `词法作用域共享`), `。`), React.createElement(MDXTag, {\n name: \"h3\",\n components: components\n }, `提供超越类型的行为`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `Swift 宏的能力不限于这些范围。让我们考虑另一种 Swift 宏：attached macro，并通过实际例子展示其潜力。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `在真实世界的编程中，我们通常从简单定义的类型开始。下面是一个例子：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `struct User {\n\n var name: String\n\n var avatar: URL\n\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，随着仓库的增长，`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `struct`), ` 的大小可能会相应增加：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `struct User {\n\n var name: String\n\n var avatar: URL\n\n var avatarsInDifferentScales: [Int : URL]\n\n var userID: String\n\n var socialMedias: [String]\n\n var brief: String\n\n // ...\n\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `由于示例中的每个属性在 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `struct`), ` 中都需要进行堆内存分配来存储数据，复制该结构体的成本也会增加。堆分配的次数与复制过程中的 retain 操作次数相对应。由于 retain 是原子操作，这可能导致用户交互时出现延迟，并浪费内存空间。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `为了将结构体的复制成本降到最低，我们可以通过将属性聚合到一个用于存储的类实例中，并在修改属性时复制该用于存储的类实例，从而使原本的结构体采用写入时复制行为：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `struct User {\n\n // 聚合了原本的结构体属性的堆存储容器类型\n private class Storage {\n\n var name: String\n\n // 其他属性 ...\n\n }\n\n // 堆存储容器实例\n private var _storage: Storage\n\n init(name: String, ...) {\n self._storage = Storage(name: name, ...)\n }\n\n // 提供写入时复制行为\n private func makeStorageUniqueIfNeeded() {\n if !isKnownUniquelyReferenced(&_storage) {\n _storage = Storage(name: name, ...)\n }\n }\n\n // 结构体中被重写的属性\n var name: String {\n get { return _storage.name }\n set {\n makeStorageUniqueIfNeeded()\n _storage.name = newValue\n }\n }\n\n // 其他被重写的属性 ...\n\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `为了进一步理解这个技术，下面的示例说明了在采用写入时复制行为之前和之后的工作细节的差异：`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"figure\",\n components: components,\n parentName: \"p\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"a\",\n components: components,\n parentName: \"figure\",\n props: {\n \"href\": \"/static/355742c47821c848e024407c6b9fb31f/1c292/working-details-before-and-after-adopting-the-copy-on-write-behavior.png\"\n }\n }, React.createElement(MDXTag, {\n name: \"img\",\n components: components,\n parentName: \"a\",\n props: {\n \"title\": \"采用写入时复制行为之前和之后的工作细节\",\n \"alt\": \"采用写入时复制行为之前和之后的工作细节\",\n \"src\": \"/static/355742c47821c848e024407c6b9fb31f/1c292/working-details-before-and-after-adopting-the-copy-on-write-behavior.png\",\n \"srcSet\": [\"/static/355742c47821c848e024407c6b9fb31f/1c292/working-details-before-and-after-adopting-the-copy-on-write-behavior.png 1x\", \"/static/5bb29f579ffc5e90b1ace40439de1058/5db75/working-details-before-and-after-adopting-the-copy-on-write-behavior%402x.png 2x\", \"/static/dcb79b50d3c0bda474ea46f5bca29ae3/16891/working-details-before-and-after-adopting-the-copy-on-write-behavior%403x.png 3x\"],\n \"loading\": \"lazy\"\n }\n })), `\n `, React.createElement(MDXTag, {\n name: \"figcaption\",\n components: components,\n parentName: \"figure\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"span\",\n components: components,\n parentName: \"figcaption\"\n }, `\n 采用写入时复制行为之前和之后的工作细节\n `), `\n `))), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `这是一种在复制大型结构体时提高性能的有效技术。在真实世界的测试中，我通过采用这种技术改进了字节跳动的一个应用程序的性能，将特定场景的 FPS 从 48 提高到了 56，并将调试时的内存使用量减少了 600MB。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，上面展示的方法可能很繁琐。它不仅涉及大量手写的代码，而且还增加了程序的维护成本。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `更重要的是，这种技术无法封装在 Swift 中的任何现有类型中：无论是 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `class`), `、`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `struct`), `、`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `enum`), ` 还是 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `protocol`), `。这是因为我对结构体所做的是通过将现有成员变形为另一种形式来扩展类型的行为。由于我们只能通过聚合、类继承和协议遵从来重用类型，这些都无法帮助我们封装这段逻辑。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `但是，Swift 宏提供了我们想要的。我们可以使用 Swift 宏封装这个代码转换过程，并以更优雅的方式来处理之前的示例。`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `@COW\nstruct User {\n\n var name: String\n\n var avatar: URL\n\n var avatarsInDifferentScales: [Int : URL]\n\n var userID: String\n\n var socialMedias: [String]\n\n var brief: String\n\n // ...\n\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `是的。就像我展示的那样简单。通过向结构体添加一个名为 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `@COW`), ` 的 attached macro，我们为该结构体引入了写入时复制的行为。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `这个宏所做的事情只不过是我们在之前的示例中手动编写的内容 —— 向结构体添加堆存储容器并将存储属性转换为计算属性，以便将访问转发到堆存储容器中：`), React.createElement(MDXTag, {\n name: \"pre\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"code\",\n components: components,\n parentName: \"pre\",\n props: {\n \"className\": \"language-swift\"\n }\n }, `@COW\nstruct User {\n\n // @COW 宏展开开始\n private class Storage {\n\n var name: String\n\n // 其他属性 ...\n\n }\n\n private var _$storage: Storage\n\n private func makeStorageUniqueIfNeeded() {\n if !isKnownUniquelyReferenced(&_$storage) {\n _$storage = Storage(name: name, ...)\n }\n }\n\n init(name: String, ...) {\n self._$storage = Storage(name: name, ...)\n }\n // @COW 宏展开结束\n\n // @COW 宏展开开始\n @COWIncluded(storage: _$storage)\n // @COW 宏展开结束\n var name: String {\n // @COWIncluded 宏展开开始\n get { return _$storage.name }\n set {\n makeStorageUniqueIfNeeded()\n _$storage.name = newValue\n }\n // @COWIncluded 宏展开结束\n }\n\n}\n`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，所有这些都是在一个自动的过程中发生的：Swift 编译器对 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `User`), ` 结构体进行类型检查，然后使用经过类型检查的 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `User`), ` 结构体作为参数来调用宏展开。最后，`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `@COW`), ` 宏通过理解 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"p\"\n }, `User`), ` 结构体中的内容生成代码。通过这个自动的机制，维护成本已经被消除。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `从上面展示的宏展开中可以观察到，attached Swift macro 可以扩展类型成员并通过添加 accessors 重写属性。扩展的内容不仅为类型带来了新的行为，还共享了扩展点的「命名空间」。值得注意的是，向存储属性添加 accessors 也将其语义从存储属性更改为计算属性。`), React.createElement(MDXTag, {\n name: \"h2\",\n components: components\n }, `结论`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `通过研究Swift中现有的代码重用手段以及了解新加入的 Swift 宏的特点，我们可以得出以下结论：`), React.createElement(MDXTag, {\n name: \"ul\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `Swift 宏是另一种封装形式，它不会带来任何新的运行时能力。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `Swift 宏通过在编译时转换程序员的代码来生成代码。这意味着我们也可以将编译时验证整合进去。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `与 Swift 中现有的代码重用特性不同， Swift 宏默认情况下不会保护其宏展开内容免受应用点现有内容的影响。另外，它也可以改变应用点语义。宏作者在实现 Swift 宏时应该注意潜在的陷阱和问题。具体而言：`, React.createElement(MDXTag, {\n name: \"ul\",\n components: components,\n parentName: \"li\"\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `对于 freestanding Swift macro，它们不仅可以影响应用点的控制流，还可以共享词法作用域。`), React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `对于 attached Swift macro，它们不仅可以为类型扩展成员，还可以为属性提供 accessor。宏展开内容也共享扩展点的「命名空间」。此外，accessor macro 还可以通过添加 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `get`), `、`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `set`), ` 或其他文档中未记录的 accessor（如 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `_read`), `、`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `_modify`), `、`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `unsafeAddressor`), ` 和 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `unsafeMutableAddressor`), `）将存储属性转换为计算属性。`)))), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"figure\",\n components: components,\n parentName: \"p\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"a\",\n components: components,\n parentName: \"figure\",\n props: {\n \"href\": \"/static/59c4f742d8386703938c36fb1093fe1e/61cee/how-swift-macro-works.png\"\n }\n }, React.createElement(MDXTag, {\n name: \"img\",\n components: components,\n parentName: \"a\",\n props: {\n \"title\": \" Swift 宏的工作原理\",\n \"alt\": \" Swift 宏的工作原理\",\n \"src\": \"/static/59c4f742d8386703938c36fb1093fe1e/61cee/how-swift-macro-works.png\",\n \"srcSet\": [\"/static/59c4f742d8386703938c36fb1093fe1e/61cee/how-swift-macro-works.png 1x\", \"/static/f49705b982817146d84bfaf4c8518d00/ab540/how-swift-macro-works%402x.png 2x\", \"/static/b81b6bc64b6f6f46bc76930f4d50284f/0095f/how-swift-macro-works%403x.png 3x\"],\n \"loading\": \"lazy\"\n }\n })), `\n `, React.createElement(MDXTag, {\n name: \"figcaption\",\n components: components,\n parentName: \"figure\"\n }, `\n `, React.createElement(MDXTag, {\n name: \"span\",\n components: components,\n parentName: \"figcaption\"\n }, `\n Swift 宏的工作原理\n `), `\n `))), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `这些性质不仅为程序员提供了另一种代码重用的选项，还能够封装涉及编译时检查、控制流操控以及为类型添加行为的编程概念，并且无需依赖继承或其他运行时技术。这些性质在 Swift 中以前从未实现过。毫无疑问，它们定义了 Swift 宏的独特优势。`), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, `然而，给予 Swift 宏优势的特性同样也引入了潜在的陷阱和问题。我们将在接下来的文章中深入探讨这个主题。`), React.createElement(MDXTag, {\n name: \"h2\",\n components: components\n }, `资源`), React.createElement(MDXTag, {\n name: \"ul\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, `一个实现了 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `#Color`), ` 和 `, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `#unwrap`), ` 宏的 playground 项目（需要`, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `git checkout strengths-and-essence`), `）`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"a\",\n components: components,\n parentName: \"p\",\n props: {\n \"href\": \"https://github.com/WeZZard/SwiftMacroRevisited\"\n }\n }, `WeZZard/SwiftMacroRevisited`)), React.createElement(MDXTag, {\n name: \"ul\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"li\",\n components: components,\n parentName: \"ul\"\n }, React.createElement(MDXTag, {\n name: \"inlineCode\",\n components: components,\n parentName: \"li\"\n }, `@COW`), ` 宏的生产级实现：`)), React.createElement(MDXTag, {\n name: \"p\",\n components: components\n }, React.createElement(MDXTag, {\n name: \"a\",\n components: components,\n parentName: \"p\",\n props: {\n \"href\": \"https://github.com/wezzard/cowmacro\"\n }\n }, `WeZZard/COWMacro`)));\n }\n\n}\nMDXContent.isMDXComponent = true;","scope":""},"headings":[{"value":"现有代码重用手段解决了什么问题？","depth":2},{"value":"函数","depth":3},{"value":"类型","depth":3},{"value":"模块","depth":3},{"value":"总结","depth":3},{"value":"Swift 宏在哪些方面表现出色？","depth":2},{"value":"编译时转换和验证","depth":3},{"value":"提供超越函数的行为","depth":3},{"value":"提供超越类型的行为","depth":3},{"value":"结论","depth":2},{"value":"资源","depth":2}]}}},"earlierPostExcerpt":{"slug":"/post/2023/03/adapting-reference-semantics-model-in-swiftui-the-basics-f521","title":"在 SwiftUI 中适配引用语义模型 -- 基础篇","subtitle":"","createdTime":"2023-03-02T00:00:00.000Z","tags":["SwiftUI","Swift","适配器模式","引用语义","Binding"],"category":"Programming","file":{"childMdx":{"excerpt":"介绍 最近，我的一位同事试图将引用语义模型用 ObservableObject 和 @StateObject 迁移到 SwiftUI。由于网上有很多关于用这种方式来迁移引用语义模型到 SwiftUI 的例子，在这篇文章中我不打算重点讨论这种方法的一般情况，而是想重点讨论在我和我的同事寻找答案使其代码正常工作的过程中发现的更有价值的三个话题。这些话题是： 在 SwiftUI 中真相源 (Source of Truth) 是什么？ 在 SwiftUI…"}}},"laterPostExcerpt":{"slug":"/post/2023/08/swift-macro-revisited-traps-and-pitfalls-1034","title":"再探 Swift 宏 - 陷阱与缺陷","subtitle":"","createdTime":"2023-08-10T00:00:00.000Z","tags":["Swift","宏"],"category":"编程","file":{"childMdx":{"excerpt":"在之前的文章中，我们学习了使得 Swift 宏独一无二的优势和本质。文中的示例工作正常，但是我们现在可以放心大胆地实现任何 Swift 宏了吗？ 答案是否定的。 给 Swift 宏带来优势的特性也会引入陷阱与缺陷，从而让程序员自己给自己造成麻烦。在本文中，我想向你展示我发现的一些问题以及避免它们的方法。 陷阱与缺陷 控制流的潜在混乱 在之前的文章中的 #unwrap 示例中，Swift 宏展开可能涉及到 控制流操控 和 词法作用域共享 ： 展开之前： 展开之后： 由于示例宏展开中涉及控制流的 return…"}}}},"pageContext":{"postId":"bfebcd5e-37cf-5ace-be71-d0ea1b5d8e48","earlierPostId":"50422053-00c8-522e-a118-2c12b7f4d13f","laterPostId":"c743b528-1454-53f9-9a0b-8aebda6e8d68"}}