SWIFT是iOS、MacOS、Watch OS和tvOS应用程序开发的一种新的编程语言。尽管如此，SWIFT的许多部分将从您在C和Object-C中开发的经验中耳熟能详。

SWIFT提供了它自己的所有基本C和Object-C类型的版本，包括Int对于整数，Double和Float对于浮点值，Bool对于布尔值，以及String用于文本数据。SWIFT还提供了三种主要集合类型的强大版本，Array, Set，和Dictionary。

与C一样，SWIFT使用变量通过标识名存储和引用值。SWIFT还广泛使用了值不能更改的变量。这些常量被称为常量，并且比C中的常量强大得多。当您使用不需要更改的值时，在SWIFT中使用常量可以使代码更安全、更清晰。

除了熟悉的类型之外，SWIFT还引入了目标C中找不到的高级类型，例如元组。元组使您能够创建和传递值的分组。可以使用元组作为单个复合值从函数返回多个值。

SWIFT还引入了可选类型，用于处理缺少值的问题。选项者要么说“在那里”是一个值，它等于x或“那里”不是一点价值也没有“。使用选项词与使用nil在Object-C中使用指针，但它们适用于任何类型，而不仅仅是类。选美运动员不仅比选秀更安全，更有表现力。nil目标C中的指针，它们是SWIFT许多最强大功能的核心。

斯威夫特类型安全语言，这意味着语言可以帮助您明确代码可以使用的值的类型。如果代码的一部分需要String，类型安全性将防止您将其传递给Int是错误的。同样，类型安全可防止意外传递可选内容。String到需要非可选代码的代码段。String。类型安全性帮助您在开发过程中尽早捕获和修复错误。

常数和变量

常量和变量关联一个名称(例如maximumNumberOfLoginAttempts或welcomeMessage)具有特定类型的值(如数字)。10或者绳子"Hello")。A的值常量设置好后不能更改，而变量可以在将来设置为不同的值。

声明常量和变量

常量和变量必须在使用前声明。属性声明常量。let关键字和变量。var关键词。下面是一个例子，说明如何使用常量和变量来跟踪用户尝试登录的次数：

放任 最大NumberOfLoginAttempt = 10
瓦尔 CurentLoginAttempt = 0

此代码可理解为：

“声明一个名为maximumNumberOfLoginAttempts，并给它一个价值为10。然后，声明一个名为currentLoginAttempt，并给出它的初始值0.”

在本例中，允许登录尝试的最大次数被声明为常量，因为最大值从不更改。当前登录尝试计数器被声明为变量，因为此值必须在每次登录尝试失败后递增。可以在单行上声明多个常量或多个变量，以逗号分隔：

瓦尔 x = 0.0, y = 0.0, z = 0.0

注
如果代码中存储的值不会更改，请始终将其声明为常量，并使用let关键词。仅将变量用于存储需要更改的值。
类型注释
你可以提供一个类型注释声明常量或变量时，要明确常量或变量可以存储的值类型。编写类型注释，方法是在常量或变量名之后加上冒号，然后是空格，然后是要使用的类型的名称。

此示例为名为welcomeMessage，指示变量可以存储String价值：

瓦尔 欢迎讯息: 弦

声明中的冒号表示“…”。…型，“所以上面的代码可以理解为：
“声明一个名为welcomeMessage那是类型的String.”

“类型”一词String“意思”可以存储任何String价值。“把它看作是可以存储的“事物的类型”(或“事物的类型”)。

这个welcomeMessage变量现在可以设置为任何字符串值，没有错误：

欢迎讯息 = “你好”

您可以在单行上定义同一类型的多个相关变量，用逗号分隔，在最终变量名之后使用单个类型的注释：

瓦尔 红色, 绿色, 蓝色: 双倍

注
在实践中，很少需要编写类型注释。如果在定义常量或变量时为其提供初始值，SWIFT几乎总是可以推断用于该常量或变量的类型，如类型安全和类型推断，在welcomeMessage示例中，不提供初始值，因此welcomeMessage变量是用类型注释指定的，而不是从初始值中推断出来的。

命名常量和变量
常量和变量名称可以包含几乎任何字符，包括Unicode字符：

放任 π = 3.14159
放任 你好 = “你好世界”
放任 🐶🐮 = “狗牛”

常量和变量名称不能包含空格字符、数学符号、箭头、私有使用Unicode标量值或行和框绘制字符。它们也不能以数字开头，尽管数字可能包含在名称的其他地方。

一旦声明了某个类型的常量或变量，就不能用相同的名称再次声明它，也不能将其更改为存储不同类型的值。你也不能把一个常量变成一个变量，或者一个变量变成一个常数。

注
如果需要为常量或变量指定与保留的SWIFT关键字相同的名称，请用backticks(`)当使用它作为名称时。但是，除非您没有绝对的选择，否则不要使用关键字作为名称。

可以将现有变量的值更改为兼容类型的另一个值。在本例中，friendlyWelcome从"Hello!"到"Bonjour!":

瓦尔 友好欢迎 = “你好！”
友好欢迎 = “好极了！”
//友好欢迎现在是“好极了！”

与变量不同，常量的值在设置后不能更改。在编译代码时，尝试这样做会被报告为错误：

放任 语言名称 = “斯威夫特”
语言名称 = “SWIFT++”
//这是编译时错误：无法更改语言名。

打印常数和变量
属性打印常量或变量的当前值。print(_:separator:terminator:)职能：

列印(友好欢迎)
//打印“Bonjour！”

这个print(:separator:terminator:)函数是一个全局函数，它将一个或多个值打印到适当的输出。例如，在Xcode中，print(:separator:terminator:)函数在Xcode的“控制台”窗格中打印其输出。这个separator和terminator参数具有默认值，因此在调用此函数时可以省略它们。默认情况下，函数通过添加行中断来终止它打印的行。若要在值之后打印不间断行的值，请将空字符串作为终止符传递--例如，print(someValue, terminator: "")。

SWIFT使用字符串插值将常量或变量的名称作为占位符包含在较长的字符串中，并提示SWIFT将其替换为该常量或变量的当前值。将名称包装在括号中，并在开始括号之前用反斜杠转义它：

列印(“欢迎友爱的当前价值是\(友好欢迎)")
//打印“友好欢迎的当前价值是Bonjour！”

注
所有可用于字符串内插的选项均在字符串插值

意见

使用注释在代码中包含不可执行的文本，作为对自己的提示或提醒。在编译代码时，SWIFT编译器将忽略注释。
SWIFT中的注释与C中的注释非常相似。单行注释以两个正斜杠开头(//):

//这是一个评论。

多行注释以正斜杠开头，后面跟着星号(/)并以星号结尾，后面跟着一个正斜杠(/):

/*这也是一个评论
而是多行写的。**

与C中的多行注释不同，SWIFT中的多行注释可以嵌套在其他多行注释中。您可以通过启动多行注释块，然后在第一个块内启动第二个多行注释来编写嵌套注释。然后关闭第二个块，然后是第一个块：

/*这是第一个多行注释的开始。
/*这是第二个嵌套的多行注释。**
这是第一个多行注释的结尾。**

嵌套的多行注释使您能够快速、轻松地注释掉大量代码块，即使代码中已经包含了多行注释。

ps；iOS开发交流技术：欢迎你的加入，不管你是大牛还是小白都欢迎入驻 ，分享BAT,阿里面试题、面试经验，讨论技术， 大家一起交流学习成长

分号

与许多其他语言不同，SWIFT不要求您编写分号(;)在代码中的每个语句之后，尽管您可以这样做，如果您愿意的话。然而，分号是如果要在一行上编写多个单独的语句，则需要：

放任 猫 = “🐱”; 列印(猫)
//打印“🐱”

整数

整数是没有小数分量的整数，如42和-23。整数是签名(正、零或负)或未签名(正或零)。

SWIFT以8、16、32和64位形式提供有符号整数和无符号整数。这些整数遵循类似于C的命名约定，因为8位无符号整数是类型的。UInt8，并且32位有符号整数的类型为Int32。与SWIFT中的所有类型一样，这些整数类型具有大写名称。

整数界

可以访问每个整数类型的最小值和最大值。min和max物业：

放任 MinValue = UInt 8.敏  //minValue等于0，类型为UInt 8
放任 最大值 = UInt 8.马克斯  //maxValue等于255，类型为UInt 8

这些属性的值是适当大小的数字类型(如UInt8因此，可以在表达式中与相同类型的其他值一起使用。

INT

在大多数情况下，您不需要选择要在代码中使用的特定整数大小。SWIFT提供了额外的整数类型，Int，它的大小与当前平台的本地单词大小相同：

在32位平台上，Int是和Int32.
在64位平台上，Int是和Int64.
除非您需要使用整数的特定大小，否则请始终使用Int对于代码中的整数值。这有助于代码的一致性和互操作性。即使在32位平台上，Int可以将任何值存储在-2,147,483,648和2,147,483,647，并且足够大，足以容纳许多整数范围。

UINT

SWIFT还提供无符号整数类型，UInt，它的大小与当前平台的本地单词大小相同：

在32位平台上，UInt是和UInt32.
在64位平台上，UInt是和UInt64.

注
使用UInt只有当您特别需要一个与平台的本地字大小相同的无符号整数类型时。如果不是这样的话，Int即使要存储的值已知为非负值，也是首选的。始终如一地使用Int对于整数值，可以帮助代码互操作性，避免了在不同数字类型之间进行转换的需要，并匹配整数类型推断，如类型安全和类型推断

浮点数

浮点数是带有小数分量的数字，如3.14159, 0.1，和-273.15.

浮点类型可以表示比整数类型更大范围的值，并且可以存储比存储在Int。SWIFT提供了两种有符号的浮点数类型：

Double表示64位浮点数.
Float表示32位浮点数.

注
Double具有至少15位十进制数字的精度，而Float可能只有6位小数。要使用的适当浮点类型取决于代码中需要处理的值的性质和范围。在两种类型都合适的情况下，Double是首选。

类型安全与类型推断

斯威夫特类型安全语言。类型安全语言鼓励您明确代码可以使用的值类型。如果代码的一部分需要String，你不能把它传给Int是错误的。

因为SWIFT是类型安全的，所以它执行类型检查编译代码时，将任何不匹配的类型标记为错误。这使您能够在开发过程中尽早捕获和修复错误。

类型检查可以帮助您在处理不同类型的值时避免错误。但是，这并不意味着您必须指定声明的每个常量和变量的类型。如果不指定所需值的类型，SWIFT将使用类型推理找出合适的类型。类型推断使编译器能够在编译代码时自动推断特定表达式的类型，只需检查所提供的值即可。

由于类型推断，SWIFT所需的类型声明比C或Object-C等语言少得多。常量和变量仍然是显式类型的，但是指定它们的类型的大部分工作都是为您完成的。

当您声明具有初始值的常量或变量时，类型推断特别有用。这通常是通过分配文字值(或文字)到声明常量或变量的点。(文字值是直接出现在源代码中的值，如42和3.14159在下面的例子中。

例如，如果将文本值赋值为42对于一个新的常量，没有说明它是什么类型，Swift推断出您希望这个常量是Int，因为您已经用一个看起来像整数的数字初始化了它：

放任 有意义的生活 = 42
//signOfLife被推断为Int类型

同样，如果不为浮点文字指定类型，Swift将推断要创建Double:

放任 派 = 3.14159
//pi推断为双重类型

斯威夫特总是选择Double(而不是Float)当推断浮点数的类型时。

如果将整数和浮点数文字组合在表达式中，则Double将从上下文中推断：

放任 另一种PI = 3 + 0.14159
//另一种PI也被推断为双重类型

的字面值3本身没有显式类型，因此适当的输出类型Double从浮点文字的存在推断为加法的一部分。

数字文字

整数字面值可以写为：

A 十进制数字，没有前缀
A 双星数字，带a0b前缀
阿八进制数字，带a0o前缀
A 十六进制数字，带a0x前缀
所有这些整数文本的十进制值为17:

放任 小数整数 = 17
放任 二元整数 = 0b10001 //17，二进制表示法
放任 八进制整数 = 0o21 //17，以八进制符号表示
放任 十六进制整数 = 0x11 //17，十六进制表示法
浮点文字可以是十进制(没有前缀)，也可以是十六进制(带有0x前缀)。它们必须始终在小数点两边都有一个数字(或十六进制数)。十进制浮点数也可以有一个可选的指数，用大写或小写表示e；十六进制浮标必须有一个指数，用大写或小写表示。p.

对于指数为1的十进制数exp，则基数乘以10。exp:

1.25e2意味着1.25 x 102，或125.0.
1.25e-2意味着1.25 x 10-2，或0.0125.
对于指数为1的十六进制数exp，则基数乘以2。exp:

0xFp2意味着15x22，或60.0.
0xFp-2意味着15x2-2，或3.75.
所有这些浮点文本的十进制值为12.1875:

放任 小数倍 = 12.1875
放任 指数倍 = 1.21875e1
放任 十六进制双倍 = 0xC.3p0

数字文本可以包含额外的格式，以使它们更易于阅读。整数和浮点数都可以用额外的零填充，还可以包含下划线以帮助提高可读性。两种类型的格式都不会影响文字的基础值：

放任 履带双倍 = 000123.456
放任 一兆 = 1_000_000

放任 刚刚超过一兆 = 1_000_000.000_000_1

数值类型转换

使用Int输入代码中所有通用的整数常量和变量，即使它们是已知的非负的。在日常情况下使用默认的整数类型意味着整数常量和变量在代码中立即可互操作，并将匹配整数文字值的推断类型。

可获取一份swift资料大全

仅当其他整数类型因来自外部源的显式大小的数据，或为性能、内存使用或其他必要的优化而需要时才使用。在这些情况下使用显式大小的类型有助于捕获任何意外值溢出，并隐式地记录所使用数据的性质。

整数转换

对于每种数字类型，可以存储在整数常量或变量中的数字范围是不同的。阿Int8常量或变量可以在-128和127，而UInt8常量或变量可以在0和255。在编译代码时，不适合大小整数类型的常量或变量的数字报告为错误：

放任 不能否定: UInt 8 = -1
//UInt 8无法存储负数，因此这将报告一个错误
放任 太大: 第8期 = 第8期.马克斯 + 1
//Int 8不能存储大于其最大值的数字，
//因此，这也将报告一个错误

因为每个数字类型都可以存储不同的值范围，所以您必须根据具体情况选择数字类型转换。这种选择中的方法可以防止隐藏的转换错误，并有助于在代码中明确类型转换意图。

因为每个数字类型都可以存储不同的值范围，所以您必须根据具体情况选择数字类型转换。这种选择中的方法可以防止隐藏的转换错误，并有助于在代码中明确类型转换意图。

若要将一种特定数字类型转换为另一种数字类型，请使用现有值初始化所需类型的新编号。在下面的示例中，常量twoThousand是类型的UInt16，而常数one是类型的UInt8。它们不能直接加在一起，因为它们不是同一类型的。相反，此示例调用UInt16(one)创建一个新的UInt16值初始化为one，并使用此值代替原始值：

放任 二千: UInt 16 = 2_000
放任 一: UInt 8 = 1
放任 两千和一 = 二千 + UInt 16(一)

因为加法的两边现在都是类型UInt16，允许添加。输出常数(twoThousandAndOne)推断为类型UInt16，因为它是2的之和UInt16价值。

SomeType(ofInitialValue)是调用SWIFT类型的初始化程序并传入初始值的默认方法。在幕后，UInt16具有接受UInt8值，因此此初始化程序用于创建一个新的UInt16从现有的UInt8。你不能进去任何在这里输入，但是-它必须是一个类型，其中UInt16提供初始化程序。扩展现有类型以提供接受新类型(包括您自己的类型定义)的初始化程序。

整数和浮点转换

整数和浮点数字类型之间的转换必须显式化：

放任 三 = 3
放任 点OneFourOneFive9 = 0.14159
放任 派 = 双倍(三) + 点OneFourOneFive9
//pi=3.14159，并推断为Double类型

这里，常数的值three用于创建类型的新值。Double，使得加法的两边都是相同的类型。如果不进行此转换，则将不允许添加。

浮点到整数的转换也必须是显式的.类初始化整数类型。Double或Float价值：

放任 整数PI = INT(派)
//整PI等于3，并推断为Int类型

在以这种方式初始化新的整数值时，浮点值总是被截断。这意味着4.75成4，和-3.9成-3.

注
组合数值常量和变量的规则与数值文本的规则不同。字面值3可以直接添加到文字值中。0.14159，因为数字文本本身没有显式类型。它们的类型只有在编译器计算它们的时候才能推断出来。

类型别名

类型别名为现有类型定义其他名称。类定义类型别名。typealias关键词。

当您希望以上下文更合适的名称引用现有类型时，类型别名非常有用，例如在处理来自外部源的特定大小的数据时：

类型 AudioSample = UInt 16

一旦定义了类型别名，就可以在任何可能使用原始名称的地方使用别名：

瓦尔 最大幅值 = AudioSample.敏
//maxampitudeFound现在为0

这里,AudioSample的别名。UInt16。因为这是一个别名，调用AudioSample.min实际上打电话UInt16.min，它提供的初始值为0为maxAmplitudeFound变量。

布尔人

斯威夫特布尔型类型，称为Bool。布尔值称为逻辑因为他们只能是真假的。SWIFT提供两个布尔常量值，true和false:

放任 橙橙 = 千真万确
放任 萝卜 = 假的

的类型orangesAreOrange和turnipsAreDelicious被推断为Bool因为它们是用布尔值初始化的。同.一样Int和Double上面，您不需要将常量或变量声明为Bool如果你把他们true或false一旦你创造了它们。当SWIFT代码使用其他类型已知的值初始化常量或变量时，类型推断有助于使SWIFT代码更加简洁和可读性。

布尔值在处理条件语句(如if声明：

如果 萝卜 {
    列印(“嗯，美味的萝卜！”)
} 其他 {
    列印(“哇，萝卜太可怕了。”)
}
//指纹“哦，萝卜太可怕了。”

条件语句，例如if语句将在控制流

SWIFT的类型安全性防止非布尔值被替换。Bool。以下示例报告编译时错误：

放任 i = 1
如果 i {
    //此示例将不编译，并将报告一个错误
}
然而，下面的另一个例子是有效的：

放任 i = 1
如果 i == 1 {
    //此示例将成功编译
}

的结果i == 1比较是类型的Bool，因此，第二个示例通过了类型检查。

与SWIFT中的其他类型安全示例一样，这种方法避免了意外错误，并确保代码的特定部分的意图总是明确的。

元组

元组将多个值分组为单个复合值。元组中的值可以是任意类型的，而不必是同一类型的。

在这个例子中，(404, "Not Found")是描述Http状态码。HTTP状态代码是Web服务器在请求网页时返回的一个特殊值。身份代码404 Not Found如果请求不存在的网页，则返回。

放任 Http 404错误 = (404, “找不到”)
//http404Error为类型(Int，String)，并等于(404，“未找到”)

这个(404, "Not Found")元组聚在一起Int和一个String给HTTP状态代码两个单独的值：一个数字和一个人类可读的描述。它可以被描述为“一个类型的元组”。(Int, String)”.

您可以从任何类型的排列中创建元组，它们可以包含任意数量的不同类型。没有什么能阻止你拥有一个类型的元组(Int, Int, Int)，或(String, Bool)或者其他你需要的排列。

你可以的分解元组的内容分为单独的常量或变量，然后像往常一样访问这些常量或变量：

放任 (状态码, 状态讯息) = Http 404错误
列印(“状态代码是\(状态码)")
//打印“状态代码为404”
列印(“状态消息是\(状态讯息)")
//打印“找不到状态消息”

如果您只需要一些元组的值，请忽略带有下划线的部分元组(_)当你分解元组时：

放任 (只是状态代码, _) = Http 404错误
列印(“状态代码是\(只是状态代码)")
//打印“状态代码为404”

或者，使用从零开始的索引数访问元组中的单个元素值：

列印(“状态代码是\(Http 404错误.0)")
//打印“状态代码为404”
列印(“状态消息是\(Http 404错误.1)")
//打印“找不到状态消息”

定义元组时，可以将元组中的各个元素命名为：

放任 Http200Status = (状态码: 200, 描述: “好”)

如果将元素命名为元组，则可以使用元素名称访问这些元素的值：

列印(“状态代码是\(Http200Status.状态码)")
//打印“状态代码为200”
列印(“状态消息是\(Http200Status.描述)")
//打印“状态消息正常”

元组作为函数的返回值特别有用。尝试检索网页的函数可能返回(Int, String)元组类型来描述页面检索的成功或失败。通过返回一个包含两个不同值的元组(每个值来自不同的类型)，该函数提供了更多关于其结果的有用信息，而不是只返回单个类型的单个值。

注
元组对于简单的相关值组很有用。它们不适合创建复杂的数据结构。如果您的数据结构可能更复杂，则将其建模为类或结构，而不是元组。

选项

你用选项在可能没有值的情况下。可选表示两种可能性：要么在那里是一个值，您可以打开可选的选项来访问该值，或者在那里。不是一点价值都没有。

注
选择词的概念在C或目标C中不存在。目标C中最近的东西是返回的能力。nil从否则会返回对象的方法中，使用nil意思是“缺少有效对象”。但是，这只适用于对象--它不适用于结构、基本C类型或枚举值。对于这些类型，Object-C方法通常返回一个特殊值(如NSNotFound)表示没有值。这种方法假设方法的调用方知道有一个特殊的值可供测试，并记得要检查它。斯威夫特的选项让你表示任何类型的，而不需要特殊的常量。

下面是一个例子，说明如何使用选项词来处理缺少值的问题。斯威夫特Int类型具有一个初始化程序，它试图将String值转换为Int价值。但是，并不是每个字符串都可以转换为整数。弦"123"可以转换为数值。123，但是绳子"hello, world"没有明显的数字值可转换为。

下面的示例使用初始化程序尝试将String变成Int:

放任 可能数 = "123"
放任 转换数 = INT(可能数)
//转换编号被推断为“INT？”或“可选INT”类型

因为初始化程序可能会失败，所以它将返回任选 Int，而不是Int。任选Int写成Int?，不是Int。问号表示它包含的值是可选的，这意味着它可能包含一些 Int值，否则它可能包含一点价值也没有。(它不能包含任何其他内容，例如Bool值或aString价值。要么是Int或者根本不算什么。)

零

通过指定特殊值将可选变量设置为无值状态。nil:

瓦尔 服务器响应代码: INT? = 404
//serverResponseCode包含实际INT值404
服务器响应代码 = 零
//serverResponseCode现在不包含任何值

注
你不能用nil非可选常量和变量。如果代码中的常量或变量需要在某些条件下处理缺少值的情况，请始终将其声明为适当类型的可选值。

如果在未提供默认值的情况下定义可选变量，则该变量将自动设置为nil对你来说：

瓦尔 测量员: 弦?
//测量员自动设置为零

注
斯威夫特nil与nil目标-C。在目标C中，nil指向不存在的对象的指针。在斯威夫特nil不是指针，而是缺少某种类型的值。任选任何类型可以设置为nil，而不仅仅是对象类型。

If语句和强制展开
您可以使用if语句，通过将可选项与nil。使用“等于”运算符执行此比较(==)或“不等于”运算符(!=).

如果一个可选选项有一个值，它被认为是“不等于”nil:

如果 转换数 != 零 {
    列印(“转换编号包含一些整数值。”)
}
//print“转换编号包含一些整数值。

一旦你确定是吗？包含一个值，您可以通过添加感叹号(!)到可选名称的末尾。感叹号有效地说：“我知道这个选项肯定有一个值，请使用它。”这被称为强制展开任择的价值：

如果 转换数 != 零 {
    列印(“转换编号的整数值为\(转换数!).")
}
//print“转换编号的整数值为123。

注试着用!若要访问不存在的可选值，将触发运行时错误。始终确保可选选项包含非-nil使用前的值!强行拆开它的价值。

可选绑定

你用可选绑定查找可选值是否包含值，如果包含，则将该值作为临时常量或变量使用。可选绑定可与if和while语句，以检查可选值中的值，并将该值提取为常量或变量，作为单个操作的一部分。

为if声明如下：

如果 放任 常量名 = 某些选择 {
    陈述
}

您可以重写possibleNumber示例中的选项节使用可选绑定而不是强制展开：

如果 放任 实际数 = INT(可能数) {
    列印(“字符串”\(可能数)“”的整数值为\(实际数)")
} 其他 {
    列印(“字符串”\(可能数)“无法转换为整数”)
}
//打印“字符串”123的整数值为123“

此代码可理解为：

“如果Int归还Int(possibleNumber)包含一个值，设置一个名为actualNumber中包含的值。“

如果转换成功，则actualNumber常量可在if声明。它已经用包含的值初始化了。内选项，所以您不使用!后缀以访问其值。在这个例子中，actualNumber仅用于打印转换结果。

可以在可选绑定中同时使用常量和变量。如果您想要操作actualNumber的第一个分支if语句，您可以写if var actualNumber相反，包含在可选项中的值将作为变量而不是常量提供。

您可以在单个文件中包含相同数量的可选绑定和布尔条件。if语句，以逗号分隔。如果可选绑定中的任何值为nil或任何布尔条件计算为false，整个if语句的条件被认为是false。以下内容if声明相当于：

如果 放任 第一号码 = INT("4"), 放任 二次编号 = INT("42"), 第一号码 < 二次编号 && 二次编号 < 100 {
    列印("\(第一号码) < \(二次编号) < 100")
}
//打印“4<42<100”

如果 放任 第一号码 = INT("4") {
    如果 放任 二次编号 = INT("42") {
        如果 第一号码 < 二次编号 && 二次编号 < 100 {
            列印("\(第一号码) < \(二次编号) < 100")
        }
    }
}
//打印“4<42<100”

注
中使用可选绑定创建的常量和变量。if语句仅在if声明。相反，使用guard语句后面的代码行中可用。

隐式展开选项
如上所述，选项表示允许常量或变量具有“无值”。选项可以用if语句查看值是否存在，并且可以有条件地使用可选绑定对其展开，以便在存在可选值的情况下访问可选值。

有时候，从程序的结构中可以清楚地看到，一个可选的意志总有一个值，在该值第一次设置之后。在这些情况下，每次访问可选值时都需要检查和打开它，因为它可以一直被安全地假定为有一个值。

这类选项被定义为隐式展开选项。通过放置感叹号(String!)而不是问号(String?)在要选择的类型之后。使用该选项时，不要将感叹号放在可选名称后面，而是在声明该选项的类型后放置感叹号。

当第一次定义可选选项之后，可选选项的值被确认为立即存在时，隐含地展开选项是有用的，并且可以肯定地假设它在其后的每个点都存在。SWIFT中隐式展开选项的主要用法是在类初始化期间,未拥有的引用和隐式未包装的可选属性.

隐式未包装的可选选项在幕后是一个普通的可选选项，但也可以像非可选值一样使用，而无需每次访问可选值时打开它。下面的示例显示了可选字符串和隐式未包装可选字符串在以显式形式访问包装值时的行为差异。String:

放任 可能串: 弦? = “可选字符串”
放任 强迫串: 弦 = 可能串! //需要一个感叹号

放任 赋值串: 弦! = “隐式未包装的可选字符串。”
放任 隐含串: 弦 = 赋值串 //不需要感叹号

您可以将一个隐式未包装的可选选项想象为允许该可选选项强制(如果需要)解除包装。当您使用隐式未包装的可选值时，SWIFT首先尝试将其用作普通的可选值；如果不能将其用作可选的值，SWIFT强制--解封该值。在上面的代码中，可选值assumedString在将其值赋值给implicitString因为implicitString具有显式的、非可选类型的String。在下面的代码中，optionalString没有显式类型，所以它是一个普通的可选选项。

放任 选项串 = 赋值串
//选项字符串的类型是“String？”而且假定String不是强制-解除包装。

如果隐式未包装的可选项是nil如果您试图访问它的包装值，就会触发一个运行时错误。结果完全相同，就像在不包含值的普通可选选项之后放置感叹号一样。

您可以检查隐式未包装的可选项是否是nil与检查普通可选选项的方式相同：

如果 赋值串 != 零 {
    列印(赋值串!)
}
//打印“隐式未包装的可选字符串”。

您还可以使用带可选绑定的隐式未包装可选选项，在单个语句中检查和展开其值：

如果 放任 限定串 = 赋值串 {
    列印(限定串)
}
//打印“隐式未包装的可选字符串”。
注

当变量有可能变成nil晚些时候。如果需要检查nil值在变量的生存期内。

错误处理

你用错误处理若要响应您的程序在执行过程中可能遇到的错误条件，请执行。

与选项(它可以使用值的存在或不存在来传递函数的成功或失败)不同，错误处理允许您确定失败的根本原因，并在必要时将错误传播到程序的另一部分。

当函数遇到错误条件时，抛出一个错误。该函数的调用者可以捕获错误并作出适当反应。

漏斗 坎特罗-安罗尔() 抛出 {
    //此函数可能引发或不引发错误
}

函数指示它可以通过包含throws关键字在其声明中。当您调用一个可以引发错误的函数时，您可以在try关键字到表达式。

SWIFT自动将错误从当前作用域传播出去，直到由catch条款。

做 {
    试一试 坎特罗-安罗尔()
    //没有引发错误
} 捕获 {
    //引发错误
}

A do语句创建一个新的包含作用域，允许将错误传播到一个或多个catch条款。

下面是一个如何使用错误处理来响应不同错误条件的示例：

漏斗 制造安桑威奇() 抛出 {
    // ...
}

做 {
    试一试 制造安桑威奇()
    饭碗()
} 捕获 桑德威彻.外清洁 {
    洗衣()
} 捕获 桑德威彻.丢失积分(放任 配料) {
    购买Groceries(配料)
}

在本例中，makeASandwich()功能将抛出一个错误，如果没有干净的菜是可用的，如果任何成分是丢失的。因为makeASandwich()可以引发错误，函数调用将被包装在try表情。通过将函数调用包装在do语句中，引发的任何错误都将传播到提供的catch条款。

如果没有引发错误，则eatASandwich()函数被调用。如果引发错误并与SandwichError.outOfCleanDishes案例，那么washDishes()函数将被调用。如果引发错误并与SandwichError.missingIngredients案例，那么buyGroceries(_:)函数与关联的[String]值捕获的catch模式。

断言和先决条件

断言和先决条件是在运行时进行的检查。在执行任何进一步的代码之前，您可以使用它们来确保基本条件得到满足。如果断言或前提条件中的布尔条件计算为true，代码执行将继续如常进行。如果条件计算为false，程序的当前状态无效；代码执行结束，应用程序终止。

您可以使用断言和先决条件来表示您在编写代码时所做的假设和期望，因此可以将它们作为代码的一部分。断言帮助您在开发过程中发现错误和不正确的假设，先决条件帮助您检测生产中的问题。

除了在运行时验证您的期望之外，断言和先决条件也成为代码中一种有用的文档形式。中讨论的错误条件不同。错误处理上面，断言和先决条件不用于可恢复或预期的错误。因为失败的断言或先决条件指示无效的程序状态，因此无法捕获失败的断言。

使用断言和先决条件并不能替代设计代码的方式，即不太可能出现无效条件。但是，使用它们来执行有效的数据和状态会使应用程序在出现无效状态时更可预测地终止，并有助于使问题更易于调试。一旦检测到无效状态，就停止执行也有助于限制该无效状态所造成的损害。

断言和先决条件之间的区别在于当它们被选中时：断言只在调试版本中被检查，但是前提条件在调试和生产构建中都被检查。在生产构建中，断言中的条件不会被计算。这意味着您可以在开发过程中使用任意数量的断言，而不会影响生产中的性能。