<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>Terms</key>
	<dict>
		<key>Alpha</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Alpha 或 Alpha 通道与颜色的不透明度有关，范围从 `0`（完全透明）至 `1`（完全不透明）。Alpha 数据是介于 0 和 1 之间的双精度浮点数（小数）。</string>
				<key>Title</key>
				<string>Alpha 值</string>
			</dict>
		</dict>
		<key>Boolean</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>拥有 `true` 值或 `false` 值的类型。例如，`9 &lt; 7` 返回布尔值 `false`，因为 `9` 不小于 `7`。
```
var isRunning = false
```</string>
				<key>Title</key>
				<string>布尔值</string>
			</dict>
		</dict>
		<key>Double</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于储存含小数部分数字的类型；例如，3.14。</string>
				<key>Title</key>
				<string>Double</string>
			</dict>
		</dict>
		<key>ForEach</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>这个结构会[迭代](glossary://iteration)数据[集合](glossary://collection)（如数组），为集合中的每个元素创建视图。

`ForEach` 结构需要每个元素提供一个 `id`：可在 `ForEach` [构造器](glossary://initialization)中明确提供，或通过符合 `Identifiable` 协议来提供。这可让 SwiftUI 独立识别和更新 `ForEach` 生成的每个视图。
```
ForEach(symbols) { symbol in 
    Text(symbol.name)
}
```
</string>
				<key>Title</key>
				<string>ForEach</string>
			</dict>
		</dict>
		<key>Int</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于储存整数（无小数的数字）的类型，如 `10` 或 `-42`。</string>
				<key>Title</key>
				<string>Int</string>
			</dict>
		</dict>
		<key>String</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于储存一系列字符的类型，如 `"hello, world"` 或 `"dancing kittens"`。</string>
				<key>Title</key>
				<string>String</string>
			</dict>
		</dict>
		<key>Swift</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Apple 的编程语言，用于编写 iPhone、iPad、Mac、Apple Watch 和 Apple TV 的 App。</string>
				<key>Title</key>
				<string>Swift</string>
			</dict>
		</dict>
		<key>SwiftUI</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>SwiftUI 是一种声明任何 Apple 平台用户界面的现代方式。它提供了视图、控制和布局结构，供你声明 App 的用户界面。框架提供了事件处理程序，用于将轻点、手势和其他输入类型传送到 App，还提供了一系列工具，供你管理从 App 模型发送至用户看到和交互的视图及控制的数据流。</string>
				<key>Title</key>
				<string>SwiftUI</string>
			</dict>
		</dict>
		<key>absolute value</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>不带符号的数字值。例如，-12 的绝对值为 12，23.4 的绝对值为 23.4。</string>
				<key>Title</key>
				<string>绝对值</string>
			</dict>
		</dict>
		<key>abstraction</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>更为复杂东西的简化版。  抽象体会隐藏细节，这样你可以更容易地考虑代码段并将其合并。  例如，有一种[类型](glossary://type)的抽象体会隐藏该类型的实例的设置、属性和方法。</string>
				<key>Title</key>
				<string>抽象体</string>
			</dict>
		</dict>
		<key>accelerometer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>测量设备在三个方向（上下、前后、左右）上加速度的传感器。

设备处于横排方向并平放在平面上时，上下移动的加速度沿 z 轴测量，左右移动的加速度沿 y 轴测量，前后移动的加速度沿 x 轴测量。</string>
				<key>Title</key>
				<string>加速计</string>
			</dict>
		</dict>
		<key>adopt</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>即采用协议，类型为符合协议的要求提供了一套自己的实现方式，如它列出的方法和属性。</string>
				<key>Title</key>
				<string>采用</string>
			</dict>
		</dict>
		<key>algorithm</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于解决某个问题的一套分步指示或规则。例如，泡茶的一系列步骤可视为一个算法。</string>
				<key>Title</key>
				<string>算法</string>
			</dict>
		</dict>
		<key>append</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>添加到某物的末尾。例如，你可以将一个字符串附加到另一个字符串的末尾处，或将一个项目附加到项目数组。
</string>
				<key>Title</key>
				<string>附加</string>
			</dict>
		</dict>
		<key>application</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>即软件，它由代码组成，允许你执行特定的任务。例如，使用“信息”应用程序 (App) 来收发信息。</string>
				<key>Title</key>
				<string>应用程序</string>
			</dict>
		</dict>
		<key>argument</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>传入函数以自定其行为的输入值。例如，在名为 `move(distance: 3)` 的函数中，数字 `3` 是用来指定移动多少空间的实参。</string>
				<key>Title</key>
				<string>实参</string>
			</dict>
		</dict>
		<key>arithmetic operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>诸如 `+`、`-`、`*` 或 `/` 的符号，用来基于一个或多个数字执行基本数学运算。例如，`42 / 7` 和 `17 - 5` 使用了算术运算符。</string>
				<key>Title</key>
				<string>算术运算符</string>
			</dict>
		</dict>
		<key>array</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>储存按序排列的同一类项目的集合。同一个项目可以在不同的位置出现多次。

在以下代码中：`highScores`（高分）是一个[整数](glossary://Int)数组，`greetings`（问候）是一个[字符串](glossary://String)数组。
```
let highScores = [37, 34, 29, 29, 26]
let greetings = ["嗨", "再见", "你好"]
```</string>
				<key>Title</key>
				<string>数组</string>
			</dict>
		</dict>
		<key>aspect ratio</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>图像或屏幕宽和高的比例。

例如，对于宽高比为 2:1 的图像，它的宽度是高度的两倍。对于宽高比为 1:1 的图像，它的宽度和高度相等。</string>
				<key>Title</key>
				<string>宽高比</string>
			</dict>
		</dict>
		<key>asset</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>资源是 App 使用的图像、声音和其他项目。你可以将资源从其他 App（如“文件”和“照片”）导入 Swift Playgrounds。</string>
				<key>Title</key>
				<string>资源</string>
			</dict>
		</dict>
		<key>assignment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>设定变量或常量值的操作。</string>
				<key>Title</key>
				<string>赋值</string>
			</dict>
		</dict>
		<key>assignment operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>`=` 符号用于设定变量的值。例如，`greeting = "你好"`将 `greeting` 的值设为`"你好"`。</string>
				<key>Title</key>
				<string>赋值运算符</string>
			</dict>
		</dict>
		<key>asynchronous process</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>代码块运行时 App 或程序的其余部分可以继续执行。同步过程会在它完成前阻止程序执行，与此相反，异步过程则可以与 App 代码的其他部分同时运行。</string>
				<key>Title</key>
				<string>异步过程</string>
			</dict>
		</dict>
		<key>asynchronous stream</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>这个[序列](glossary://sequence)的值无法全部同时获取，而是作为数值流隔一段时间产生。若要迭代异步流，你必须等待每个新值，才能对它执行操作。
				
异步流通常用于随时间产生的数据，如地颤或视频帧。</string>
				<key>Title</key>
				<string>异步流</string>
			</dict>
		</dict>
		<key>binding</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>添加 `@Binding` [属性包装器](glossary://property%20wrapper)，在储存数据的属性和显示并更改数据的视图间建立双向连接。绑定会将属性连接到储存在其他地方的可信源，而不是直接储存数据。

例如，用于切换播放和暂停的按钮可使用 `@Binding` 属性包装器，与它[容器视图](glossary://container)的属性建立绑定关系。</string>
				<key>Title</key>
				<string>绑定</string>
			</dict>
		</dict>
		<key>body</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>[视图](glossary://view)的主体是你提供视图内容的地方，由至少一个 SwiftUI 提供的[内建视图](glossary://built-in%20view)组成，或由任何你已创建的[组合视图](glossary://composed%20view)组成。</string>
				<key>Title</key>
				<string>主体</string>
			</dict>
		</dict>
		<key>bounds</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在数组中，数组可以有的索引值范围。例如，数组 `[17, 42, 95]` 可以有 0 至 2 的索引值。界限检查是验证索引值是否位于数组界限内的过程。</string>
				<key>Title</key>
				<string>界限</string>
			</dict>
		</dict>
		<key>brightness</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>进入相机的光线量，范围从 `0`（无光）至 `1`（全光）。亮度是介于 `0` 和 `1` 之间的 [Double](glossary://Double)（小数）。</string>
				<key>Title</key>
				<string>亮度</string>
			</dict>
		</dict>
		<key>bug</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>代码中阻止应用程序按预期运行的错误。 
</string>
				<key>Title</key>
				<string>程序错误</string>
			</dict>
		</dict>
		<key>built-in view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>由 [SwiftUI](glossary://SwiftUI) 框架提供的[视图](glossary://view)，如 `Button`、`Text` 或 `Image` 视图。内建视图用作构建块，以在[用户界面](glossary://user%20interface)中创建更复杂的[组合视图](glossary://composed%20view)。</string>
				<key>Title</key>
				<string>内建视图</string>
			</dict>
		</dict>
		<key>bundle</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>App 在捆绑包中储存它的代码以及任何它需要的资源，如数据文件、图像、声音。每个 App 都有一个主捆绑包，还可能有其他指名的捆绑包。捆绑包是磁盘上的一个文件夹，其中的资源按定义明确的子文件夹整理。不同的平台和捆绑包类型可能具有不同的捆绑包结构。</string>
				<key>Title</key>
				<string>捆绑包</string>
			</dict>
		</dict>
		<key>call</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>调用代码中的函数就是让这个函数运行，执行函数中定义的操作。</string>
				<key>Title</key>
				<string>调用</string>
			</dict>
		</dict>
		<key>callback</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>有时函数或对象可能需要回到你面前来提供数据，或者告诉你在它运行期间发生了重要的事件。你可以给它传递一个函数或[委托](glossary://delegate)对象，让它可以进行回调来实现这个功能。

回调常用来处理[异步](glossary://asynchronous%20process)流程。</string>
				<key>Title</key>
				<string>回调</string>
			</dict>
		</dict>
		<key>chaining</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>[调用](glossary://call)一系列[函数](glossary://function)的技巧，其中每个函数都会返回一个对象，按顺序被下一个函数运行。调用的函数会一起串联在单个语句中。
				
例如，你可以串联 SwiftUI [修饰符](glossary://modifier)，因为修饰符是接收[视图](glossary://view)、应用某些更改后再返回另一个视图的[方法](glossary://method)。</string>
				<key>Title</key>
				<string>串联</string>
			</dict>
		</dict>
		<key>class</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>类是代码的容器，用作蓝图以制作同一类事物的多个[实例](glossary://instance)。就像蓝图可能定义对象（如自行车）的功能和行为一样，类将这些定义为[属性](glossary://property)和[方法](glossary://method)。

制作类的实例时，这个实例包含蓝图定义的所有属性和方法。每个实例共享相同的属性和方法，但实例的属性值可单独更改，这可让你自定从类创建（或实例化）的每个实例。例如，自行车类可能含颜色属性，让你创建红色或蓝色的自行车。

类与[结构](glossary://structure)相似，但有两个重要不同：类是[引用类型](glossary://reference%20type)，即它总是按引用拷贝；并且类可以从其他类继承定义。</string>
				<key>Title</key>
				<string>类</string>
			</dict>
		</dict>
		<key>classification</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在机器学习中，分类是一种算法，它会从已标记的数据集中学习，然后利用学习内容来分类新的观察结果。

例如，犬种分类器会根据狗品种的标记图像进行训练。如果你给这个分类器展示一张狗的新图像，它可将这个输入分类为其中一个犬种。</string>
				<key>Title</key>
				<string>分类</string>
			</dict>
		</dict>
		<key>closed range</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>从下限到上限（包括上限）的区间。

在 Swift 中，值范围 1-3 可写作 1...3。在本例中，范围包括下限 1 并数至上限 3。
```
let closedRange = 1...3
for i in closedRange { 
	print(i) // 1 2 3
}
```</string>
				<key>Title</key>
				<string>闭合范围</string>
			</dict>
		</dict>
		<key>closure</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>闭包是在特定位置运行的[函数](glossary://function)，它不需要名称。
					
```
scene.setOnStartHandler {
    // 闭包的主体
}
```
                    
闭包可以捕捉并储存对上下文中定义的任何常量和变量的引用。这就是所谓的闭合这些常量和变量。</string>
				<key>Title</key>
				<string>闭包</string>
			</dict>
		</dict>
		<key>code comment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>代码注释是程序员记录其代码的方式。  你可以用两个斜杠和一个空格作为单行注释的开头；例如“// 这是我的注释。”。  运行代码时，代码注释不会执行。</string>
				<key>Title</key>
				<string>代码注释</string>
			</dict>
		</dict>
		<key>code expression</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>可通过求值返回值的一段代码。例如，如果 `months` 是包含 12 个项目的数组，代码表达式 `months.count - 1` 返回值 `11`。</string>
				<key>Title</key>
				<string>代码表达式</string>
			</dict>
		</dict>
		<key>coding</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>编写命令、代码结构和算法以创建应用程序的操作。</string>
				<key>Title</key>
				<string>编程</string>
			</dict>
		</dict>
		<key>collection</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>诸如[数组](glossary://array)或[范围](glossary://range)的一种数据结构，用于储存多段数据。
```
let heights = [1, 5, 7]
let closedRange = 1...8
```</string>
				<key>Title</key>
				<string>集合</string>
			</dict>
		</dict>
		<key>command</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>告诉应用程序执行特定操作的代码。 </string>
				<key>Title</key>
				<string>命令</string>
			</dict>
		</dict>
		<key>comment out</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>将代码行变成[代码注释](glossary://code%20comment)，让此行代码不运行。在任意一行代码前添加 `//` 可实现这个操作。例如：
                
`// level.run()`</string>
				<key>Title</key>
				<string>注释掉</string>
			</dict>
		</dict>
		<key>comparison operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>诸如 `==`、`!=`、`&lt;`、`&gt;`、`&lt;=` 或 `&gt;=` 的符号，用于比较两个值。比较运算符用在 `if` 语句或 `while` 循环的条件中，返回的布尔值表示比较结果是否为 `true`。例如，`6 &gt; 8` 将 `6` 和 `8` 进行比较，并返回 `false`。</string>
				<key>Title</key>
				<string>比较运算符</string>
			</dict>
		</dict>
		<key>compiler error</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>编译器错误是由代码中的差错引起的。你会在左侧页边空白和工具栏中看到它显示为红色圆点。</string>
				<key>Title</key>
				<string>编译器错误</string>
			</dict>
		</dict>
		<key>composed view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>通过合并一个或多个[内建](glossary://built-in%20view)或组合视图创建的[视图](glossary://view)。
</string>
				<key>Title</key>
				<string>组合视图</string>
			</dict>
		</dict>
		<key>composition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>合并应用程序的各个小部分，以形成更易处理和理解的较大部分的过程。</string>
				<key>Title</key>
				<string>组合</string>
			</dict>
		</dict>
		<key>compound assignment operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>合并赋值（设定变量的值）和另一个运算（如加法或减法）的运算符。例如，如果 `a` 的当前值为 `1`，使用 `a += 3` 将在 `1` 的基础上加 `3`，并将结果赋予 `a`，因此 `a` 现在的值为 `4`。</string>
				<key>Title</key>
				<string>复合赋值运算符</string>
			</dict>
		</dict>
		<key>computed property</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>计算属性不是直接储存值，而是根据其他相关值获取时的当前状态计算出一个值。

在以下示例中，area（面积）就是计算属性，`width`（宽度）和 `height`（高度）是储存属性：

```
struct RectangleCalculator { 
    var width = 10.0
    var height = 10.0
    
    var area : Double { 
        return width * height
    }
} 
```</string>
				<key>Title</key>
				<string>计算属性</string>
			</dict>
		</dict>
		<key>condition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在 [if 语句](glossary://if%20statement)等[条件代码](glossary://conditional%20code)块中，条件是一个[布尔](glossary://Boolean)值，用来确定是否运行块内的代码。

如果条件为 `true`，将运行代码块。如果为 `false`，将跳过条件代码。
```
let x = 4

if x &lt; 5 { 
	// 条件为真，if 块中的代码运行。
}

if x &gt; 5 { 
	// 条件为假，if 块中的代码不运行。
}
```</string>
				<key>Title</key>
				<string>条件</string>
			</dict>
		</dict>
		<key>conditional code</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>仅当满足特定条件时才运行的代码。例如，[if 语句](glossary://if%20statement)和 [while 循环](glossary://while%20loop)包含仅在条件为 `true` 时或期间才运行的条件代码。
```
if x &gt; 5 { 
	// 仅当 x 大于 5 时才运行代码
}
```</string>
				<key>Title</key>
				<string>条件代码</string>
			</dict>
		</dict>
		<key>confidence</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在机器学习中，置信度是机器学习模型的[预测](glossary://prediction)概率。预测的置信度可以帮助我们了解机器学习模型的表现。</string>
				<key>Title</key>
				<string>置信度</string>
			</dict>
		</dict>
		<key>conform</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>类型为符合协议的要求提供了自己的实现方式时，这个类型即称为符合协议。</string>
				<key>Title</key>
				<string>符合</string>
			</dict>
		</dict>
		<key>console</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>可在代码运行时查看代码调试输出的地方。当你在代码中调用 `print(_:)` 时，传入的值会在控制台中显示。</string>
				<key>Title</key>
				<string>控制台</string>
			</dict>
		</dict>
		<key>constant</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个被命名的容器，用于储存不可变值。</string>
				<key>Title</key>
				<string>常量</string>
			</dict>
		</dict>
		<key>container</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>容器是一个在其中保存其他视图的视图。</string>
				<key>Title</key>
				<string>容器</string>
			</dict>
		</dict>
		<key>coordinates</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>唯一确定空间中的位置的一组数字。例如，(100, -200) 是二维空间中一个点的坐标，其中 x 坐标为 100，y 坐标为 -200。</string>
				<key>Title</key>
				<string>坐标</string>
			</dict>
		</dict>
		<key>data</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>电脑处理或储存的信息，与针对其作用的代码不同。</string>
				<key>Title</key>
				<string>数据</string>
			</dict>
		</dict>
		<key>data cleaning</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>检查数据集并移除或修改不正确、不完整、重复或格式化不正确的任何数据的过程。

数据清理可确保机器学习模型只使用最相关且正确的可用数据[训练](glossary://training)，从而提高它的准确性。</string>
				<key>Title</key>
				<string>数据清理</string>
			</dict>
		</dict>
		<key>data flow</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>App 中数据的移动，该数据中的变化情况会导致 App 的状态或 UI 发生更改。</string>
				<key>Title</key>
				<string>数据流</string>
			</dict>
		</dict>
		<key>data model</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>App 中所用数据的代码表现形式，它反映了数据组织。[用户界面](glossary://user%20interface)可以显示来自数据模型的数据，也可以与它交互以修改数据。数据模型担当了 App [可信源](glossary://source%20of%20truth)的角色。</string>
				<key>Title</key>
				<string>数据模型</string>
			</dict>
		</dict>
		<key>data separation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>这个概念是指 App 的[数据模型](glossary://data%20model)应当和显示该数据并与之交互的[用户界面](glossary://user%20interface)分开定义。数据分离可让你将数据模型修改和 UI 修改独立进行，让你更容易了解 App 如何运行，以及改进 App 的可测试性。</string>
				<key>Title</key>
				<string>数据分离</string>
			</dict>
		</dict>
		<key>debug</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>找出并修复代码中阻止应用程序正确运行的问题。</string>
				<key>Title</key>
				<string>调试</string>
			</dict>
		</dict>
		<key>declaration</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在应用程序中创建新东西的一段代码，如函数、变量或自定类型。例如，`let planet = "Earth"` 声明了一个新常量 `planet`，并给它赋值 `"Earth"`。

以下代码声明了一个 `AppData` 类型的变量 `data`，但没有给它赋初始值。

```
var data : AppData
```</string>
				<key>Title</key>
				<string>声明</string>
			</dict>
		</dict>
		<key>decode</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>将数据从高效的储存格式（如 JSON）转换成代码中更易处理的格式。</string>
				<key>Title</key>
				<string>解码</string>
			</dict>
		</dict>
		<key>decomposition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>将大问题分解成更易管理的小问题的过程。</string>
				<key>Title</key>
				<string>分解</string>
			</dict>
		</dict>
		<key>decrement</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>使数字按整数值减小，通常按 1 递减。</string>
				<key>Title</key>
				<string>递减</string>
			</dict>
		</dict>
		<key>define</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>为新创建的一段代码（如函数、变量或自定类型）提供确切值或行为。例如，通过在函数内提供一组命令来告诉函数应当如何做来定义函数。</string>
				<key>Title</key>
				<string>定义</string>
			</dict>
		</dict>
		<key>delegate</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>将一个特殊对象提供给另一个对象，以在重要事件发生时通知你。委托对象通常符合某个[协议](glossary://protocol)，并具有可调用的函数以与代码回复通信。被调用的委托函数称为委托[回调](glossary://callback)。

委托是一种在对象间通信所用的常见形式，尤其是在[异步](glossary://asynchronous%20process)流程中。</string>
				<key>Title</key>
				<string>委托</string>
			</dict>
		</dict>
		<key>destination view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>[用户](glossary://user)点按或轻点 `NavigationStack` 或 `NavigationSplitView` 内的 `NavigationLink` 后显示的视图。</string>
				<key>Title</key>
				<string>目的视图</string>
			</dict>
		</dict>
		<key>dot notation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于访问实例的属性或调用实例的方法的一种语法形式。例如，`expert.toggleSwitch()` 调用 `expert` 实例上的 `toggleSwitch()` 方法。</string>
				<key>Title</key>
				<string>点记法</string>
			</dict>
		</dict>
		<key>edge case</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在罕见情况下或在操作参数的极端情况下发生的一种情况，可预测或不可预测。

例如，在构建 iPad App 时，当你将设备语言更新为使用从右到左文本的语言（如阿拉伯语）时，你的 App 会崩溃。</string>
				<key>Title</key>
				<string>边界情况</string>
			</dict>
		</dict>
		<key>efficiency</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一种衡量一段代码在使用尽可能少的资源（如内存或电量）的情况下快速执行其预期目的的程度的手段。</string>
				<key>Title</key>
				<string>效率</string>
			</dict>
		</dict>
		<key>element</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>[数组](glossary:///array)或[范围](glossary://range)等[集合](glossary://collection)中的一个项目。

```
let letters = ["a", "b", "c"] // “a”是第一个元素，“b”是第二个，“c”是第三个。
```</string>
				<key>Title</key>
				<string>元素</string>
			</dict>
		</dict>
		<key>else block</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>`if` 语句中的最后一个代码块。如果 `if` 语句中的所有其他条件都为 `false`，则运行 `else` 块。

```
if hopper.isFacingStep { 
	// if 块
} else if hopper.isFacingUpdraft { 
	// else if 块
} else { 
	// else 块
}
```</string>
				<key>Title</key>
				<string>else 块</string>
			</dict>
		</dict>
		<key>else if block</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>`if` 语句中的一个代码块，用于检查 [if 块](glossary://if%20block)或任何其他 `else if` 块未检查的条件。

```
if hopper.isFacingStep { 
	// if 块
} else if hopper.isFacingUpdraft { 
	// else if 块
} else { 
	// else 块
}
``</string>
				<key>Title</key>
				<string>else if 块</string>
			</dict>
		</dict>
		<key>encode</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>将数据从代码中易于处理的格式转换成高效的储存格式，如 JSON。</string>
				<key>Title</key>
				<string>编码</string>
			</dict>
		</dict>
		<key>enumeration</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于定义一组称为用例的相关值的类型。

例如，`Direction`（方向）枚举定义了每个方向的用例：`north`（北）、`south`（南）、`east`（东）和 `west`（西）。
```
enum Direction { 
	case north, south, east, west
}
```
[传入](glossary://pass%20in)枚举值时，总是选取其中的一个用例；例如：
 ```
 moveIn(direction: .north)
```</string>
				<key>Title</key>
				<string>枚举</string>
			</dict>
		</dict>
		<key>environment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>视图的环境提供了对已定义的值集合的访问方式。有些自动反映了系统状态、用户设置或视图状态，例如视图的色彩方案、文本样式或焦点状态。有些提供了有用的默认值，如文本栏的行限制。你可以通过 `@Environment` [属性包装器](glossary://property%20wrapper)访问环境值来对它们进行读取。环境值的完整列表可在[此处](doc://com.apple.documentation/documentation/swiftui/environmentvalues)找到。</string>
				<key>Title</key>
				<string>环境</string>
			</dict>
		</dict>
		<key>environment object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>添加 `@EnvironmentObject` [属性包装器](glossary://property%20wrapper)，来声明容器视图或顶级视图提供的可观测对象属性。如果将属性声明为环境对象，别忘了通过调用它的 `environmentObject(_:)` 修饰符在顶级视图中设定相应的模型实例。</string>
				<key>Title</key>
				<string>环境对象</string>
			</dict>
		</dict>
		<key>event</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>能被电脑应用程序检测到的操作。输入（比如按下一个按钮或转动屏幕）会触发一个事件。</string>
				<key>Title</key>
				<string>事件</string>
			</dict>
		</dict>
		<key>event handler</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在事件发生后被调用来处理事件的函数。</string>
				<key>Title</key>
				<string>事件处理程序</string>
			</dict>
		</dict>
		<key>extension</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>为[类](glossary://class)、[结构](glossary://structure)、[枚举](glossary://enumeration)或[协议](glossary://protocol)等现有[类型](glossary://type)新增功能的一种方式。

扩展可让你将[方法](glossary://method)和[属性](glossary://property)添加到现有类型。以下代码将 `cubed()`（立方）方法和 `isOdd`（奇数）属性添加到了 `Int`（整数）类型：

```
extension Int { 
	func cubed() -&gt; Int { 
        return self * self * self
    }
    
    var isOdd : Bool { 
        return self % 2 == 1
    }
}

let two : Int = 2
print(two.cubed()) // 8
print(two.isOdd) // 假
```</string>
				<key>Title</key>
				<string>扩展</string>
			</dict>
		</dict>
		<key>filtering</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>通过处理集合或数据结构中的数据来产生一组新数据。</string>
				<key>Title</key>
				<string>过滤</string>
			</dict>
		</dict>
		<key>focus state</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>表示视图能否接收用户输入的值，如键入到文本栏中。使用 `@FocusState` [属性包装器](glossary://property%20wrapper)以及 `focused(_:equals:)` 和 `focused(_:)` 修饰符来创建一个视图，使它的焦点值基于用户交互自动更新，还能以编程方式在特定时间聚焦或取消聚焦。</string>
				<key>Title</key>
				<string>焦点状态</string>
			</dict>
		</dict>
		<key>font</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>特定设计样式、粗细和大小的一组文本字符。字体的设计样式称为字样，这个设计的各种变化形成字样系列。例如，HelveticaNeue 是一种字样，10 点的 HelveticaNeue-Bold 是一种字体。</string>
				<key>Title</key>
				<string>字体</string>
			</dict>
		</dict>
		<key>for loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>运行一定次数的重复代码块。

循环可能会[迭代](glossary://iterate)任何数据[集合](glossary://collection)，如[范围](glossary://range%20value)或[数组](glossary://array)，为集合中的每个元素运行这个循环块。

在以下示例中，循环定义了循环变量 `value`（值），你可以通过它来访问集合中当前元素的值：
```
for value in 1...4 { 
	byte.moveForward()
	byte.jump(height: value)
}
```</string>
				<key>Title</key>
				<string>for 循环</string>
			</dict>
		</dict>
		<key>framework</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>框架是包含共享资源的目录。这些资源可能在单个软件包中包括源文件、图像文件、本地化字符串、参考文档等等。多个应用程序可以同时使用所有此类资源。系统按需将它们载入内存中，并在可能时在所有应用程序间共享同一个资源副本。</string>
				<key>Title</key>
				<string>框架</string>
			</dict>
		</dict>
		<key>full function name</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>函数的全名，包括其由冒号 (`:`) 分隔的参数的名称；例如，`move(to:duration:)`。</string>
				<key>Title</key>
				<string>函数全名</string>
			</dict>
		</dict>
		<key>function</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个已命名的代码块，会在名称被[调用](glossary://call)时运行。函数可以[参数](glossary://parameter)形式接收数据，还可在它的代码完成运行时选择性地[返回](glossary://return)数据。在类型中定义的函数叫做[方法](glossary://method)。

以下是 `turnRight()`（右转）函数定义示例。你可以写下 `turnRight()` 来调用这个函数；随后代码会执行，即运行三次 `turnLeft()`（左转）。

```
func turnRight() { 
	turnLeft()
	turnLeft()
	turnLeft()
}
```</string>
				<key>Title</key>
				<string>函数</string>
			</dict>
		</dict>
		<key>function definition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>函数定义描述了函数的功能、预期接收的内容和运行完成时返回的内容。</string>
				<key>Title</key>
				<string>函数定义</string>
			</dict>
		</dict>
		<key>fuzzy autocomplete</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>自动补齐代码的一种方法，它使用模糊字符串搜索以查找匹配的变量、常量、类型和其他符号。模糊字符串搜索并不准确，但会基于你键入的字符查找相关匹配项。 

例如，如果搜索与“scale”相关的[视图修饰符](glossary://modifier)，你可以简单地键入 `.scale`，然后就会得到以 `.scale` 开头的自动补齐选项，如 `.scaledToFill` 和 `.scaleEffect`，不过还会有“模糊”匹配项，如 `.imageScale` 和 `.grayscale`。
</string>
				<key>Title</key>
				<string>模糊自动补齐</string>
			</dict>
		</dict>
		<key>g</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>加速度或单位质量受力的度量单位。1g（1g 力）等于地球重力加速度，约 9.8 米每二次方秒。</string>
				<key>Title</key>
				<string>g</string>
			</dict>
		</dict>
		<key>global function</key>
		<dict>
			<key>FirstUse</key>
			<dict>
				<key>PageReference</key>
				<string></string>
				<key>_LOCALIZABLE_</key>
				<dict>
					<key>Title</key>
					<string></string>
				</dict>
			</dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>可在项目的任何文件中访问的函数。</string>
				<key>Title</key>
				<string>全局函数</string>
			</dict>
		</dict>
		<key>global scope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>可从同一个[模块](glossary://module)中任何源文件的代码访问的符号。在源文件顶层定义的任何实例、类型或函数均默认具有全局范围。</string>
				<key>Title</key>
				<string>全局范围</string>
			</dict>
		</dict>
		<key>global variable</key>
		<dict>
			<key>FirstUse</key>
			<dict>
				<key>PageReference</key>
				<string></string>
				<key>_LOCALIZABLE_</key>
				<dict>
					<key>Title</key>
					<string></string>
				</dict>
			</dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>可在项目的任何文件中访问的变量。</string>
				<key>Title</key>
				<string>全局变量</string>
			</dict>
		</dict>
		<key>grayscale</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>灰度范围，从白色到黑色。</string>
				<key>Title</key>
				<string>灰度</string>
			</dict>
		</dict>
		<key>gyroscope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>从三个维度测量设备方向的传感器：设备的前后倾斜、设备的左右倾斜，以及设备绕中心的旋转。</string>
				<key>Title</key>
				<string>陀螺仪</string>
			</dict>
		</dict>
		<key>half open range</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>从下限到上限（不包括上限）的半开区间。

在 Swift 中，值范围 1-3 可写作 1..&lt;4。在本例中，范围包括下限 1 并数至（但不包括）值 4。
```
let halfOpenRange = 1..&lt;4
for i in halfOpenRange { 
	print(i) // 1 2 3
}
```</string>
				<key>Title</key>
				<string>半开范围</string>
			</dict>
		</dict>
		<key>hertz</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>赫兹 (Hz) 是每秒中的一个周期。在声振动中，1 Hz 代表每秒一个声波。人类可以听到 20 Hz 至 16,000 Hz 之间的声音。</string>
				<key>Title</key>
				<string>赫兹</string>
			</dict>
		</dict>
		<key>hue</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>色轮上的颜色的色调。这是介于 `0` 和 `1` 之间的双精度浮点数（小数）。</string>
				<key>Title</key>
				<string>色相</string>
			</dict>
		</dict>
		<key>if block</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>`if` 语句中的第一个代码块。`if` 块在 `if` 语句中的条件为 `true` 时运行。
```
if blu.isFacingStep { 
	blu.jump()
}
```</string>
				<key>Title</key>
				<string>if 块</string>
			</dict>
		</dict>
		<key>if statement</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用来基于一个或多个条件的值运行代码的代码结构。`if` 语句中的第一个代码块是 `if` 块。
```
if blu.isFacingStep { 
	blu.jump()
}
```
`if` 语句可能还包含进行额外检查的其他块，如 `else` 块和 `else if` 块。
```
if blu.isFacingStep { 
	blu.jump()
} else if blu.isFacingHole { 
	blu.shapeShift(into: .bridge)
} else { 
	blu.moveForward()
}
```</string>
				<key>Title</key>
				<string>if 语句</string>
			</dict>
		</dict>
		<key>import</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在 Swift 中，`import`（导入）[声明](glossary://declaration)允许你访问在当前文件之外定义的符号，例如类型、函数、属性和方法。你可以导入[模块](glossary://module)或[框架](glossary://framework)中的符号，如 [SwiftUI](doc://com.apple.documentation/documentation/swiftui) 或 [CoreMotion](doc://com.apple.documentation/documentation/coremotion)（核心运动）。例如，如果要使用 SwiftUI 框架，你需要将以下声明放在文件的顶部：

```
import SwiftUI
```
</string>
				<key>Title</key>
				<string>导入</string>
			</dict>
		</dict>
		<key>increment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>使数字按整数值增加，通常按 1 递增。</string>
				<key>Title</key>
				<string>递增</string>
			</dict>
		</dict>
		<key>index</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>代表[数组](glossary://array)中项目位置的数字。</string>
				<key>Title</key>
				<string>索引</string>
			</dict>
		</dict>
		<key>index out of range error</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>尝试使用数组范围外的索引访问数组时导致的错误。例如，索引 `2` 在数组 `[17, 42]` 的范围之外。</string>
				<key>Title</key>
				<string>索引超出范围错误</string>
			</dict>
		</dict>
		<key>initialization</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>创建类型的新实例的操作，它包括为类型的任何属性设定初始值。</string>
				<key>Title</key>
				<string>初始化</string>
			</dict>
		</dict>
		<key>initializer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>调用构造器以创建一个类型的新[实例](glossary://instance)。构造器必须确保该类型的所有属性都有初始值，并且常常包含其他设置代码。</string>
				<key>Title</key>
				<string>构造器</string>
			</dict>
		</dict>
		<key>inner loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>嵌套在另一个（外）循环中的重复代码块（循环）。</string>
				<key>Title</key>
				<string>内循环</string>
			</dict>
		</dict>
		<key>instance</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个特定[类型](glossary://type)的值。例如，在 `let motion = MotionSensor()` 中，`motion`（动作）是 `MotionSensor`（动作传感器）类型的实例。</string>
				<key>Title</key>
				<string>实例</string>
			</dict>
		</dict>
		<key>integer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个整数，如 `2` 或 `-5`。</string>
				<key>Title</key>
				<string>整数</string>
			</dict>
		</dict>
		<key>iterate</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>为每个数组或范围等[集合](glossary://collection)中的[元素](glossary://element)重复运行代码块。

在以下代码中，for 循环迭代 `days`（星期几）数组，一次打印出一周中的一天：
```
let days = ["周一", "周二", "周三"]

for value in days { 
	print(value)
}

// 第一个迭代：打印“周一”
// 第二个迭代：打印“周二”
// 第三个迭代：打印“周三”
```</string>
				<key>Title</key>
				<string>迭代</string>
			</dict>
		</dict>
		<key>iteration</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>重复某个过程的操作，如对数组中的每个项目执行相同的操作。</string>
				<key>Title</key>
				<string>迭代</string>
			</dict>
		</dict>
		<key>label</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>UI 元素的视觉表现形式，创建为[视图](glossary://view)。

许多 SwiftUI [内建视图](glossary://built-in%20view)同时具有标签（视觉表现形式）以及一些其他的自定义点，如 `NavigationLink` 的[目的视图](glossary://destination%20view)，或 `Button` 的[回调](glossary://callback)操作。</string>
				<key>Title</key>
				<string>标签</string>
			</dict>
		</dict>
		<key>lag</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>由处理需求和/或处理能力导致的 App 运行或响应速度下降。</string>
				<key>Title</key>
				<string>延迟</string>
			</dict>
		</dict>
		<key>leading edge</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>当用在视图中引用内容时，前缘指的是内容开始的水平位置。前缘的位置取决于你的偏好，而且通常由你的地区和语言设置决定。
                    例如，对于从左到右的语言，如英语或荷兰语，前缘位于左侧。对于从右到左的语言，如阿拉伯语或希伯来语，前缘位于右侧。</string>
				<key>Title</key>
				<string>前缘</string>
			</dict>
		</dict>
		<key>literal</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>字面量可让你使用图像库或颜色选择器将图像和颜色直接嵌入代码。字面量是在编辑器内直接以原生格式表示的数据实际值。</string>
				<key>Title</key>
				<string>字面量</string>
			</dict>
		</dict>
		<key>local scope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>本地范围在[全局范围](glossary://global%20scope)下代码组织的每个新层级处形成。例如，一个新的[类型](glossary://type)形成一个新的本地范围，并且这个类型内的函数和代码块形成自己的层级[范围](glossary://scope)。根据符号被声明的位置，你只能从同一层级范围或更低层级范围处的代码来访问它。

例如，如果变量在类型内被定义，你可从该类型内的所有函数和代码块来访问这个变量。但是，在方法内定义的常量只能在方法定义内访问。</string>
				<key>Title</key>
				<string>本地范围</string>
			</dict>
		</dict>
		<key>logical AND operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于合并两个布尔值的符号 (`&amp;&amp;`)，两个值必须都为真，整段代码才为真。例如，只有在 `a` 和 `b` 均为 `true` 时，`a &amp;&amp; b` 才为真。</string>
				<key>Title</key>
				<string>逻辑“与”运算符</string>
			</dict>
		</dict>
		<key>logical NOT operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于反转一段代码的布尔值的符号 (`!`)。例如，如果 `a` 为 `true`，则 `!a` 为 `false`。</string>
				<key>Title</key>
				<string>逻辑“非”运算符</string>
			</dict>
		</dict>
		<key>logical OR operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于合并两个布尔值的符号 (`||`)，其中有一个值必须为真，整段代码才为真。例如，只有在 `a` 或 `b` 为 `true`（或均为 `true`）时，`a || b` 才为 `true`。</string>
				<key>Title</key>
				<string>逻辑“或”运算符</string>
			</dict>
		</dict>
		<key>logical operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>诸如 `&amp;&amp;`、`||` 或 `!` 的符号，用于修改或合并布尔逻辑值 `true` 和 `false`。</string>
				<key>Title</key>
				<string>逻辑运算符</string>
			</dict>
		</dict>
		<key>loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>重复运行一定次数（如 `for` 循环）或重复运行直至满足条件（如 `while` 循环）的代码块。</string>
				<key>Title</key>
				<string>循环</string>
			</dict>
		</dict>
		<key>loop variable</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在 [for 循环](glossary://for%20loop)中，你正在[迭代](glosssary://iterate)的[集合](glossary://collection)中当前元素的值。

循环变量会储存这个值，让你在 `for` 循环主体中使用它。

在以下示例中，`value`（值）和 `letter`（字母）为循环变量：
```
for value in 1...4 { 
	print(value) // 1 2 3 4
}

for letter in ["c", "o", "d", "e"] { 
	print(letter) // c o d e 
}
```</string>
				<key>Title</key>
				<string>循环变量</string>
			</dict>
		</dict>
		<key>lower bound</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在[范围](glossary://range)中向上数的起始值。

```
let closedRange = 1...5 // 下限为 1，上限为 5
for i in closedRange { 
	print(i) // 1 2 3 4 5
}
```</string>
				<key>Title</key>
				<string>下限</string>
			</dict>
		</dict>
		<key>machine learning</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>计算机科学的一个分支，专注于开发[算法](glossary://algorithm)，来使用大量数据教机器如何学习和改进特定过程。

例如，通过使用图像[分类器](glossary://classification)并提供大量的花图像数据集，来教机器识别特定类型的花。</string>
				<key>Title</key>
				<string>机器学习</string>
			</dict>
		</dict>
		<key>machine learning model</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>通过将机器学习[算法](glossary://algorithm)应用到[训练数据集](glossary://training%20dataset)而创建的一种[数据模型](glossary://data%20model)。机器学习模型（或 ML 模型）用于根据输入源进行[预测](glossary://prediction)。</string>
				<key>Title</key>
				<string>机器学习模型</string>
			</dict>
		</dict>
		<key>magnitude</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>无视正负时值的大小，也称为数字的[绝对值](glossary://absolute%value)。

例如，`5` 和 `-5` 的大小都是 `5`。</string>
				<key>Title</key>
				<string>大小</string>
			</dict>
		</dict>
		<key>memory</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>电脑的一部分，用于（临时或永久）储存应用程序的代码及其使用的数据。</string>
				<key>Title</key>
				<string>内存</string>
			</dict>
		</dict>
		<key>metadata</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>与数据相关的补充信息。例如，照片可能包含它拍摄时位置的相关元数据。</string>
				<key>Title</key>
				<string>元数据</string>
			</dict>
		</dict>
		<key>method</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个已命名的代码块，会在它的名称被[调用](glossary://call)时运行。

方法是一种[函数](glossary://function)，但它是在[类型](glossary://type)内定义。

此段代码从叫做 `byte` 的[实例](glossary://instance)中调用方法 `moveForward()`（前进）：
```
let byte = Byte()

byte.moveForward()
```</string>
				<key>Title</key>
				<string>方法</string>
			</dict>
		</dict>
		<key>miter</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>两条画线之间的连接样式，其中拐角为尖角，而不是圆角或斜角。</string>
				<key>Title</key>
				<string>尖角</string>
			</dict>
		</dict>
		<key>modifier</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在 SwiftUI 中，修饰符用于自定视图的外观或行为。

					在下方代码中，`foregroundColor` 修饰符将 `Rectangle` 视图的颜色改成了蓝色。
					```
					Rectangle()
							.foregroundColor(.blue)
					```

					为了增加修饰符的可读性，在修饰符所修改的视图下方，每个修饰符都会单独占用一行。在这个示例中，首先会应用修饰符 `foregroundColor(.blue)`，接着是 `border(.green)`。
					```
					Rectangle()
							.foregroundColor(.blue)
							.border(.green)
					```
					
					由于修饰符是按顺序应用，所以交换它们的位置会改变结果视图的外观或行为。
				</string>
				<key>Title</key>
				<string>修饰符</string>
			</dict>
		</dict>
		<key>modularity</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>将 App 分离成各个独立部分的准则。每个独立部分都含有该部分执行 App 中单个功能所需的一切内容，例如，显示界面的单一部分，或储存 App 数据。

模块化是创建 App 的重要准则，因为它可让你更好地了解和处理功能的各个部分，在 App 出现程序错误时可更容易找出问题所在。</string>
				<key>Title</key>
				<string>模块化</string>
			</dict>
		</dict>
		<key>module</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>代码分发的单个单元，即作为单个单元构建和发布的[框架](glossary://framework)或应用程序，可通过 Swift 的[导入](glossary://import)关键词被另一个模块导入。</string>
				<key>Title</key>
				<string>模块</string>
			</dict>
		</dict>
		<key>modulo operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于将一个数除以另一个数后返回余数的符号 (`%`)。例如，`17 % 5` 返回 `2`。</string>
				<key>Title</key>
				<string>取模运算符</string>
			</dict>
		</dict>
		<key>navigation bar</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>导航界面可让你在每个屏幕上做出一个选择，直至到达目的位置。若要前往另一个目的位置，你必须沿路径折返或从头开始进行不同的选择。屏幕顶部的导航栏会显示标题，帮你记住所在位置，并提供一个返回按钮供你返回上一个屏幕。</string>
				<key>Title</key>
				<string>导航栏</string>
			</dict>
		</dict>
		<key>navigation link</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>SwiftUI [内建视图](glossary://built-in%20view)，可在用户轻点时导航至[目的视图](glossary://destination%20view)。导航链接还具有决定它视觉外观的[标签](glossary://label)。</string>
				<key>Title</key>
				<string>导航链接</string>
			</dict>
		</dict>
		<key>nest</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在一个代码块内部放置另一个重复的代码块，如循环。</string>
				<key>Title</key>
				<string>嵌套</string>
			</dict>
		</dict>
		<key>normalization</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>缩放一组数据，使缩放后的结果值介于 `0` 和 `1` 之间的过程。</string>
				<key>Title</key>
				<string>标准化</string>
			</dict>
		</dict>
		<key>observable object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>当类[符合](glossary://conform) `ObservableObject` 协议时，对它的发布值进行的任何更改都会导致使用这些值的所有视图自动更新，以反映变化。</string>
				<key>Title</key>
				<string>可观测对象</string>
			</dict>
		</dict>
		<key>observe</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>监测对象[状态的变化](glossary://state%20change)。</string>
				<key>Title</key>
				<string>观测</string>
			</dict>
		</dict>
		<key>observed object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在[视图](glossary://view)中，SwiftUI 会观测使用 `@ObservedObject` [属性包装器](glossary://property%20wrapper)的任何[属性](glossary://property)更改。如果它的值发生变化，SwiftUI 会更新视图。

被观测对象属性的类型必须[符合](glossary://conform) `ObservableObject` 协议。
				</string>
				<key>Title</key>
				<string>被观测对象</string>
			</dict>
		</dict>
		<key>observer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>观测器与[可观测对象](glossary://observable%20object)有关，它是使用可观测对象数据的任何视图或对象。当可观测对象的数据更改时，SwiftUI 会识别到更新，然后告诉观测器进行更新。</string>
				<key>Title</key>
				<string>观测器</string>
			</dict>
		</dict>
		<key>operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>诸如 `+`、`-` 或 `&amp;&amp;` 的符号，代表在一个或多个值上的操作。例如，在`1 + 2` 中，加法运算符 (`+`) 将数字 `1` 和 `2` 相加。</string>
				<key>Title</key>
				<string>运算符</string>
			</dict>
		</dict>
		<key>optional</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>代表被包装的值或没有值的类型。可选类型通常用后接问号 (`?`) 来表示。
				
例如，`Int?` 类型的变量可能包含被包装的 `Int` 值 `-43` 或 `6`，或者它的值可能为 `nil`，即没有已分配的值。</string>
				<key>Title</key>
				<string>可选</string>
			</dict>
		</dict>
		<key>outer loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>包含另一个（内）循环的重复代码块（循环）。</string>
				<key>Title</key>
				<string>外循环</string>
			</dict>
		</dict>
		<key>overfitting</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在机器学习中，模型与一组特定数据符合度过高而产生的结果。

例如，如果你的模型是检测哺乳动物图像的[分类器](glossary://classification)，但你的[训练数据集](glossary://training%20dataset)只包含狗的图像，那么模型将过拟合，导致只识别狗而忽略了兔子或鹿等其他哺乳动物。</string>
				<key>Title</key>
				<string>过拟合</string>
			</dict>
		</dict>
		<key>parameter</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于自定[函数](glossary://function)行为方式的值。[调用](glossary://call)函数时，你可以传入不同的值来更改它的行为。

在以下函数中，`distance`（距离）是一个接受 `Int`（整数）类型值的参数：
```
func move(distance: Int) { 
	for i in 1...distance { 
		moveForward()
	}
}
```

参数值 (`distance`) 可用在函数主体中，来影响它的行为方式。在本例中，你可以配合不同的整数值调用这个函数，如 `move(distance: 2)` 或 `move(distance: 5)`，来移动不同的距离。</string>
				<key>Title</key>
				<string>参数</string>
			</dict>
		</dict>
		<key>pass in</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>为函数的其中一个[参数](glossary://parameter)提供值。

在以下代码中，代码将值“你好”传入 `text`（文本）参数。
```
speak(text: "你好")
```</string>
				<key>Title</key>
				<string>传入</string>
			</dict>
		</dict>
		<key>pattern</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一组重复的情形或数据。</string>
				<key>Title</key>
				<string>模式</string>
			</dict>
		</dict>
		<key>persistence</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>储存用户数据，供 App 每次启动时重新载入的过程。如果没有持久化，App 的状态和数据会在每次 App 重新启动时还原。</string>
				<key>Title</key>
				<string>持久化</string>
			</dict>
		</dict>
		<key>pi</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>圆周率 (π) 是一个约等于 3.14 的数学常量。它是圆的周长和直径的比值。</string>
				<key>Title</key>
				<string>圆周率</string>
			</dict>
		</dict>
		<key>pitch</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>设备处于横排方向时，向右或向左旋转量或倾斜量的度量方式。  数学上来说，俯仰是指设备绕 x 轴的旋转量，度量单位是弧度，范围是 `-π/2` 至 `π/2`。</string>
				<key>Title</key>
				<string>俯仰</string>
			</dict>
		</dict>
		<key>pitch audio</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>声音的音高取决于声波的振动频率。在一段特定的时间内产生的声波越多，音调就越高。

					在音乐中，音高用于描述音符听起来是“低”还是“高”。例如，鸟鸣的音调很高，而狮子低沉的吼叫声音调则很低。</string>
				<key>Title</key>
				<string>音高</string>
			</dict>
		</dict>
		<key>placeholder view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>暂时显示的视图，以指示最终内容将载入或输入的位置。例如，用于显示载入中图像的 `ProgressView`，或文本输入位置的灰色矩形。</string>
				<key>Title</key>
				<string>占位符视图</string>
			</dict>
		</dict>
		<key>prediction</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在机器学习中，预测是机器学习模型在接收输入时的输出。

例如，对于经过了识别不同犬种训练的机器学习模型，金毛猎犬可以是它的有效预测。</string>
				<key>Title</key>
				<string>预测</string>
			</dict>
		</dict>
		<key>private</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>关键词 private 使代码仅在特定的源文件中可用。
- callout(示例):
`private class MyApp: App { }`</string>
				<key>Title</key>
				<string>private</string>
			</dict>
		</dict>
		<key>property</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在[类型](glossary://type)内部定义的一种变量（变量是一种用于储存值的被命名的容器）。

属性可使用[点记法](glossary://dot%20notation)并通过类型的[实例](glossary://instance)来访问。在以下代码中，`isFacingHole`（面向坑）是 `Hopper` 类型的一个属性。
```
if hopper.isFacingHole { 
	// 代码
}
```</string>
				<key>Title</key>
				<string>属性</string>
			</dict>
		</dict>
		<key>property wrapper</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>属性包装器是一种将常用行为模式应用到属性的简单方法。这个包装器是对属性的一种标注方式，定义了读取时它如何被储存或计算。  例如，`@State` 属性包装器告诉 SwiftUI 管理值的储存空间，并在值发生更改时，更新视图中任何使用了这个值的部分。</string>
				<key>Title</key>
				<string>属性包装器</string>
			</dict>
		</dict>
		<key>protocol</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一组可被类型（如类、结构或枚举）采用（或遵循）的要求，如方法和属性。  当类型采用一个协议时，它为符合协议的要求提供了自己的实现方式，即称为符合这个协议。</string>
				<key>Title</key>
				<string>协议</string>
			</dict>
		</dict>
		<key>pseudocode</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>对算法的一种容易读懂的描述，编写时通常混合使用日常用语和代码。</string>
				<key>Title</key>
				<string>伪代码</string>
			</dict>
		</dict>
		<key>public</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>关键词 public 使代码在项目的所有文件中都可用。
                        
- callout(示例):
`public func decorateWithSticker(space: Space) { }`
                    </string>
				<key>Title</key>
				<string>public</string>
			</dict>
		</dict>
		<key>publish</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在指定[发布属性](glossary://published%20value)的值发生更改时，向[可观测对象](glossary://observable%20object)的所有[观测器](glossary://observer)广播通知。</string>
				<key>Title</key>
				<string>发布</string>
			</dict>
		</dict>
		<key>published value</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>添加 `@Published` [属性包装器](glossary://property%20wrapper)以声明一个在属性值即将更改时通知所有[观测器](glossary://observer)的属性。当值更改时，SwiftUI 会更新所有使用它数据的视图。</string>
				<key>Title</key>
				<string>发布值</string>
			</dict>
		</dict>
		<key>radians</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>弧度类似于度，是角度的一种度量单位。角的弧度等于弧长和这个角所在圆的半径的比值。一弧度等于 180 度除以[圆周率](glossary://pi)。</string>
				<key>Title</key>
				<string>弧度</string>
			</dict>
		</dict>
		<key>range</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>[下限](glossary://lower%20bound)和[上限](glossary://upper%20bound)之间的区间。

创建范围的方式有多种，包括[闭合范围](glossary://closed%20range)和[半开范围](glossary://half%20open%20range)。

```
let closedRange = 1...4 
for i in closedRange { 
	print(i) // 1 2 3 4
}

let halfOpenRange = 1..&lt;4 
for i in halfOpenRange { 
	print(i) // 1 2 3
}
```</string>
				<key>Title</key>
				<string>范围</string>
			</dict>
		</dict>
		<key>reference type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>创建引用类型（如类或 Actor）的[实例](glossary://instance)时，它的数据会储存在共享内存中。因此，实例中只包含数据的引用，而不是独占一个副本。如果将实例[赋值](glossary://assignment)给一个变量，或者将它作为[实参](glossary://argument)传入函数，Swift 会创建相同数据的另一个引用。

实例按引用拷贝，如以下示例中所示：

```
class Bicycle {
  var color: Color
   init(color: Color) {
     self.color = color
   }
}

var redBike = Bicycle(color: .red)
var blueBike = redBike
blueBike.color = .blue
print(redBike.color) // =&gt; 红色
print(blueBike.color) // =&gt; 蓝色
// redBike 和 blueBike 共享相同数据的引用
```</string>
				<key>Title</key>
				<string>引用类型</string>
			</dict>
		</dict>
		<key>responsive</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>如果代码或用户界面对[用户交互](glossary://user%20interaction)快速反应，或对其所在环境中的更改（如视图的尺寸更改）进行适当调整，即表示代码或用户界面可响应。</string>
				<key>Title</key>
				<string>快速响应</string>
			</dict>
		</dict>
		<key>return</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>将值发回给[函数](glossary://function)的调用者。例如，函数 `contains(3)` 在数组 `[0,1,2]` 上运行时会返回 `false` 布尔值，因为这个数组不包含值 `3`。</string>
				<key>Title</key>
				<string>返回</string>
			</dict>
		</dict>
		<key>return type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>定义函数时，你可以选择定义函数运行完成时传回的输出值的类型，即返回类型。</string>
				<key>Title</key>
				<string>返回类型</string>
			</dict>
		</dict>
		<key>reusability</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>代码的一种特性，允许它在应用程序中的不同情况下被使用。</string>
				<key>Title</key>
				<string>可再用性</string>
			</dict>
		</dict>
		<key>roll</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>设备处于横排方向时，向前或向后旋转量或倾斜量的度量方式。  数学上来说，它是指设备绕 y 轴的旋转量，度量单位是弧度，范围是 `-π` 至 `π`。</string>
				<key>Title</key>
				<string>滚动</string>
			</dict>
		</dict>
		<key>root view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个在其中放置所有其他视图的视图，也叫做[顶层视图](glossary://top-level%20view)。这个视图位于[视图层次](glossary://view%20hierarchy)的顶部，并作为层级中所有[子视图](glossary://subview)的[容器视图](glossary://container)。</string>
				<key>Title</key>
				<string>根视图</string>
			</dict>
		</dict>
		<key>rubber ducky method</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一种学习方法，在这种学习方法中你需要向一个无生命物体详细地解释一个概念。采用这个方法时需要准备一个无生命物体（如小黄鸭），并对它大声解释概念，确保向小黄鸭传递理解这个概念所需要的全部信息。在解释过程中，如果你发现有信息遗漏，可留下备注以后研究。你可以在后续向小黄鸭解释时包括新发现内容。</string>
				<key>Title</key>
				<string>小黄鸭调试法</string>
			</dict>
		</dict>
		<key>saturation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>色相的强度，从灰调至全彩色。饱和度是介于 `0` 和 `1` 之间的双精度浮点数（小数）。</string>
				<key>Title</key>
				<string>饱和度</string>
			</dict>
		</dict>
		<key>scope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>你可以从中访问值或类型的项目区域。在[全局范围](glossary://global%20scope)处定义的符号可通过[模块](glossary://module)中的任何文件来访问，在[本地范围](glossary://local%20scope)处定义的符号在同一层级或更低层级的本地范围处的代码中可用。</string>
				<key>Title</key>
				<string>范围</string>
			</dict>
		</dict>
		<key>sensor</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>传感器是一种能检测事件（如温度、光线、声音或运动的变化）并返回值的设备。</string>
				<key>Title</key>
				<string>传感器</string>
			</dict>
		</dict>
		<key>sequence</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个值列表，你一次可以使用[迭代](glossary://iteration)单步调试一个值。

你可以使用 `for`-`in` 循环来迭代序列，如以下示例中的 `healthySnacks` 数组：
```
let healthySnacks = ["apple", "pear", "banana"]
for snack in healthySnacks {
	eat(snack)
}
```</string>
				<key>Title</key>
				<string>序列</string>
			</dict>
		</dict>
		<key>source of truth</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在 App 构建中一个修改所有数据的地方。与这些数据的所有其他关联仅通过引用实现，这样可以避免它的信息在其他位置重复。</string>
				<key>Title</key>
				<string>可信源</string>
			</dict>
		</dict>
		<key>speech synthesis</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>电脑生成类似人类说话的语音，通常从文本中生成。</string>
				<key>Title</key>
				<string>语音合成</string>
			</dict>
		</dict>
		<key>state</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一定时间内变量、应用程序或系统储存的信息。例如，如果变量 `level` 包含值 `4`，则它的当前状态为 `4`。</string>
				<key>Title</key>
				<string>状态</string>
			</dict>
		</dict>
		<key>state change</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>变量、应用程序或系统中储存的信息发生的更改。例如，如果变量 `level` 的值从 `4` 改为 `5`，它的状态就发生了变化。</string>
				<key>Title</key>
				<string>状态更改</string>
			</dict>
		</dict>
		<key>state object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>添加 `@StateObject` [属性包装器](glossary://property%20wrapper)以声明状态对象，并提供符合 `ObservableObject` [协议](glossary://protocol)的初始值。SwiftUI 管理状态对象的储存空间，并在它的发布值更改时更新所有使用这个值的子视图。</string>
				<key>Title</key>
				<string>状态对象</string>
			</dict>
		</dict>
		<key>state property</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在视图的[属性](glossary://property)前面添加 `@State`，以让 SwiftUI 管理值的储存。当值发生更改时，SwiftUI 会更新视图中使用这个值的任何部分。

```
@State var isOn = false
```
</string>
				<key>Title</key>
				<string>状态属性</string>
			</dict>
		</dict>
		<key>state value</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在变量前添加 `@State` 以让 SwiftUI 管理值的储存空间。值更改时，SwiftUI 会更新视图中使用这个值的所有部分。</string>
				<key>Title</key>
				<string>状态值</string>
			</dict>
		</dict>
		<key>statement</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>诸如循环或 `if` 语句的结构，用于组织应用程序中的代码。</string>
				<key>Title</key>
				<string>语句</string>
			</dict>
		</dict>
		<key>string component</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>字符串的一部分或子字符串，在字符串被分隔符分离成几部分后形成。例如，如果字符串 `"dog+cat+fish"` 被分隔符 `"+"` 分离，将产生字符串 `"dog"`、`"cat"` 和 `"fish"` 这几个成分。</string>
				<key>Title</key>
				<string>字符串成分</string>
			</dict>
		</dict>
		<key>string concatenation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>通过将一个字符串接上另一个字符串结尾来连接字符串的操作。例如，`"foot"` 和 `"ball"` 连接后成为 `"football"`。</string>
				<key>Title</key>
				<string>字符串连接</string>
			</dict>
		</dict>
		<key>string interpolation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在较长字符串中使用常量、变量或代码表达式，使它们替换为其当前值以求出字符串的值。例如，在字符串 `"Katy ate a \(fruit)."` 中，如果 `fruit` 是带有值 `"peach"` 的变量，那么在求字符串的值时，`\(fruit)` 由 `"peach"` 替换，变为 `"Katy ate a peach."`。</string>
				<key>Title</key>
				<string>字符串插值</string>
			</dict>
		</dict>
		<key>structure</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>结构是代码的容器，用作蓝图以制作同一类事物的多个[实例](glossary://instance)。就像蓝图可能定义对象（如自行车）的功能和行为一样，结构将这些定义为[属性](glossary://property)和[方法](glossary://method)。

制作结构的实例时，这个实例包含蓝图定义的所有属性和方法。每个实例共享相同的属性和方法，但实例的属性值可单独更改，这可让你自定从结构创建（或实例化）的每个实例。例如，自行车结构可能含颜色属性，让你创建红色或蓝色的自行车。

结构与[类](glossary://class)相似，但有两个重要不同：结构是[值类型](glossary://value%20type)，即它总是按值拷贝；并且结构不支持从其他结构继承。

```
struct Bicycle { 
	var color : Color 
	var type : BikeCategory
}
```</string>
				<key>Title</key>
				<string>结构</string>
			</dict>
		</dict>
		<key>subview</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一种包含在[容器](glossary://container)视图中的视图。容器可以包含任意数量的子视图，每个子视图可包含自己的子视图，以此类推。视图及其所有后代形成了[视图层次](glossary://view%20hierarchy)。</string>
				<key>Title</key>
				<string>子视图</string>
			</dict>
		</dict>
		<key>syntax</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>编写电脑可以理解并运行的代码的规则。</string>
				<key>Title</key>
				<string>语法</string>
			</dict>
		</dict>
		<key>task</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>任务在处理 App 中离散的工作单元时很有用，这样你的代码就可以保持处理重要的事情，比如处理 UI。创建任务时，它会作为程序的一部分[异步](glossary://asynchronous%20process)运行它的代码。这使得其余的代码可以处理其他的事情。代码中需要从这个任务中获取数据的部分可以 `await`（等待）任务的结果。</string>
				<key>Title</key>
				<string>任务</string>
			</dict>
		</dict>
		<key>ternary conditional operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一种快速编写条件语句的特殊方式。[运算符](glossary://operator)包含三个部分，其形式为 `condition ? trueValue : falseValue`。它类似于 [`if` 语句](glossary://if%20statement)，在 `condition` 为 `true` 时返回 `trueValue`，在 `condition` 为 `false` 时返回 `falseValue`。

在以下代码中，如果 `isOn` 为 `true`，矩形为绿色。如果 `isOn` 为 `false`，矩形为红色。

```
Rectangle()
     .foregroundColor(isOn ? .green : .red)
```

以上代码可理解为：如果 `isOn` 为 `true`，返回值 `.green`，否则返回值 `.red`。
</string>
				<key>Title</key>
				<string>三元条件运算符</string>
			</dict>
		</dict>
		<key>toolbar</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于执行特定功能的图标条。工具栏修饰符需要工具栏项集合，你可以通过添加视图集合来提供。</string>
				<key>Title</key>
				<string>工具栏</string>
			</dict>
		</dict>
		<key>top-level view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个在其中放置所有其他视图的视图，也叫做[根视图](glossary://root%20view)。这个视图位于[视图层次](glossary://view%20hierarchy)的顶部，并作为层次中所有[子视图](glossary://subview)的[容器视图](glossary://container)。</string>
				<key>Title</key>
				<string>顶层视图</string>
			</dict>
		</dict>
		<key>trailing edge</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>当用在视图中引用内容时，后缘指的是内容结束的水平位置。后缘的位置取决于你的偏好，而且通常由你的地区和语言设置决定。
                    例如，对于从左到右的语言，如英语或荷兰语，后缘位于右侧。对于从右到左的语言，如阿拉伯语或希伯来语，后缘位于左侧。</string>
				<key>Title</key>
				<string>后缘</string>
			</dict>
		</dict>
		<key>training</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在机器学习中，机器学习算法从数据集中学习的过程。

在监督学习中，模型会尝试在数据的特征和标记之间建立最精确的数学关系。在无监督学习中，模型会尝试找到数据特征本身之间的关系。</string>
				<key>Title</key>
				<string>训练</string>
			</dict>
		</dict>
		<key>training dataset</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>机器学习模型自我[训练](glossary://training)以生成[预测](glossary://prediction)所使用的数据集合。</string>
				<key>Title</key>
				<string>训练数据集</string>
			</dict>
		</dict>
		<key>type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>某种数据的属性（特征）和方法（行为）构成的被命名群组。

类型是创建一套相关功能，并让功能更易于访问的一种方式。

```
struct Person { 
	var name : Int
	var age : String 

	func greet() { 
		print("你好，朋友！")
	}
}
```</string>
				<key>Title</key>
				<string>类型</string>
			</dict>
		</dict>
		<key>typography</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>排列印刷文字的艺术和技巧，可使书面语言在显示时更清楚易读、更具吸引力。</string>
				<key>Title</key>
				<string>排版</string>
			</dict>
		</dict>
		<key>unwrap</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>从[可选](glossary://optional)类型的[实例](glossary://instance)中提取被包装的值。
				
在可选类型中解包装值通常使用 `if`-`let`：
```
var count: Int? = 48
if let unwrappedCount = count {
	print(unwrappedCount)
} else {
	print("count has no value")
}
```</string>
				<key>Title</key>
				<string>解开</string>
			</dict>
		</dict>
		<key>upper bound</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>在[范围](glossary://range%20value)中向上数至的末尾值。

```
let closedRange = 1...5 // 下限为 1，上限为 5
for i in closedRange { 
	print(i) // 1 2 3 4 5
}
```</string>
				<key>Title</key>
				<string>上限</string>
			</dict>
		</dict>
		<key>user</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>使用你 App 的人。</string>
				<key>Title</key>
				<string>用户</string>
			</dict>
		</dict>
		<key>user input</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>应用程序从与用户的交互中得到的信息，如用户触碰屏幕，使用键盘输入文本，或使用麦克风说话。 
</string>
				<key>Title</key>
				<string>用户输入</string>
			</dict>
		</dict>
		<key>user interaction</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>[用户](glossary://user)使用你的 App 时执行的操作。轻点按钮、向左轻扫屏幕、旋转设备、从 `ColorPicker` 选取颜色，以及将字符键入文本栏中，这些都是用户交互的例子。</string>
				<key>Title</key>
				<string>用户交互</string>
			</dict>
		</dict>
		<key>user interface</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用户控制 App 的方式，也叫做“UI”。这个词通常指的是 App 中用户交互的可视部分，它的元素包括图像、文本、按钮、滑块和滚动视图等。</string>
				<key>Title</key>
				<string>用户界面</string>
			</dict>
		</dict>
		<key>validation dataset</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>从机器学习模型的[训练数据集](glossary://training%20dataset)中保留的数据样本。模型会使用验证数据集来评估其预测的准确性。</string>
				<key>Title</key>
				<string>验证数据集</string>
			</dict>
		</dict>
		<key>value type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>创建值类型（如[结构](glossary://structure)）的[实例](glossary://instance)时，它的数据会储存在实例本身中。如果将实例[赋值](glossary://assignment)给一个变量，或者将它作为[实参](glossary://argument)传入函数，Swift 会创建带有数据独立副本的新实例。

实例按值拷贝，如以下示例中所示：

```
struct Bicycle {
  var color: Color
}

var redBike = Bicycle(color: .red)
var blueBike = redBike
blueBike.color = .blue
print(redBike.color) // =&gt; 红色
print(blueBike.color) // =&gt; 蓝色
// redBike 和 blueBike 分别拥有自己的一份数据副本
```</string>
				<key>Title</key>
				<string>值类型</string>
			</dict>
		</dict>
		<key>variable</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>一个被命名的容器，用于储存可变值。

变量可储存不同[类型](glossary://type)的值，如[整数](glossary://Int)、[字符串](glossary://String)和[范围](glossary://range)。
```
var favoriteNumber = 7 // 储存整数
var greeting = "你好" // 储存字符串
var repetitions = 1...5 // 储存范围
```
</string>
				<key>Title</key>
				<string>变量</string>
			</dict>
		</dict>
		<key>velocity</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>物体给定方向的速度。</string>
				<key>Title</key>
				<string>速度</string>
			</dict>
		</dict>
		<key>view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>视图是 App 用户界面的构建块，代表[符合](glossary://conform) `View` [协议](glossary://protocol)的任何可视元素。

SwiftUI 中的一些视图示例包括文本视图、图像视图、滑块、网格、按钮和形状。</string>
				<key>Title</key>
				<string>视图</string>
			</dict>
		</dict>
		<key>view hierarchy</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>用于定义视图相对于其他视图布局的结构，以层次顶部的顶层视图为参照。顶层视图可能包含任意数量的子视图，每个子视图也都可以包含自己的子视图，以此类推。</string>
				<key>Title</key>
				<string>视图层次</string>
			</dict>
		</dict>
		<key>volume</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>音量是[传感器](glossary://sensor)检测到的声音的响度。范围在 0 和 1 之间。</string>
				<key>Title</key>
				<string>音量</string>
			</dict>
		</dict>
		<key>while loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>给定条件为 `true` 时运行的一个代码块。当条件更改为 `false` 时，循环停止运行。</string>
				<key>Title</key>
				<string>while 循环</string>
			</dict>
		</dict>
		<key>wireframe</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>关卡世界中项目（如宝石、开关或砖块）的外框。线框用于指示每次关卡运行时可能随机出现的项目。</string>
				<key>Title</key>
				<string>线框</string>
			</dict>
		</dict>
		<key>yaw</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>设备平放在平面上时，围绕中心点旋转量的度量方式。  数学上来说，它是指设备绕 z 轴的旋转量，度量单位是弧度，范围是 `-π` 至 `π`。</string>
				<key>Title</key>
				<string>偏航</string>
			</dict>
		</dict>
	</dict>
</dict>
</plist>
