Swift 4官方文档中文版: The Basic(上)

该文章翻译自Apple官方文档: The Swift 4 Programming Language

Guards翻译组正在翻译Swift 4的全套文档, 这是该文档第一章节的上半部分, 下半部分我们将于明天下午发布. 如果你感兴趣, 可以关注我们的简书. 原文链接: The Basics

Swift 是一门开发 iOS, macOS, watchOS 和 tvOS 应用的新语言。即便如此，如果你有 C 或者 Objective-C 开发经验，你会发现 Swift 的有很多你熟悉的内容。Swift 提供了与 C 和 Objective-C 上所有基础数据类型，如整型Int；浮点型Double和Float；布尔型值Bool；文本型数据String 。 Swift 还提供了三个基本的集合类型，Array ，Set和 Dictionary ，详见集合类型。

和 C 语言类似，Swift 使用变量来进行存储并通过变量名来关联对应的值。在 Swift 中，不可变的变量非常常用，它们就是常量，而且比 C 语言的常量更强大。在 Swift 中，如果你要处理的值不需要改变，那使用常量可以让你的代码更加安全并且更清晰地表达你的意图。

除了我们熟悉的类型，Swift 还增加了 Objective-C 中没有的高阶数据类型, 比如元组Tuples。元组可以让你创建或者传递一组数据，当函数需要返回单一复合值时，你可以用一个元组可以返回多个值。

Swift 还增加了Optional类型(译者注: Optional类型即可选类型)，用于处理值不存在的情况。可选的意思是 “这里有一个值，并且它等于x ” 或 “这里没有值” 。可选有点像在 Objective-C 中使用nil ，但是它可以用在任何类型上，不仅仅是类。可选类型比 Objective-C 中的 nil指针更加安全也更具表现力，它是 Swift 许多强大特性的重要组成部分。 Swift 是一门类型安全的语言，这意味着 Swift 可以让你清楚地知道值的类型。如果你的代码期望得到一个String ，类型安全会阻止你错误地传入一个Int。同样的，如果你的代码期望得到一个 String，类型安全会阻止你意外传入一个可选的 String 。类型安全可以帮助你在开发阶段尽早发现并修正错误。

常量和变量

常量和变量把一个名字（比如maximumNumberOfLoginAttempts或者 welcomeMessage）和一个指定类型的值（比如数字 10或者字符串"Hello"）关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。

声明常量和变量

常量和变量必须在使用前声明，用关键字let来声明常量和关键字 var来声明变量。下面的例子展示了如何用常量和变量来记录用户尝试登录的次数：

  let maximumNumberOfLoginAttempts = 10
  var currentLoginAttempt = 0

这两行代码可以被理解为： “声明一个名字是maximumNumberOfLoginAttempts的新常量，并给它一个值 10。然后，声明一个名字是currentLoginAttempt的变量并将它的值初始化为0 ”。

在这个例子中，允许的最大尝试登录次数被声明为一个常量，因为这个值不会改变。当前尝试登录次数被声明为一个变量，因为每次尝试登录失败的时候都需要增加这个值。你可以在一行中声明多个常量或者多个变量，用逗号隔开：

  var x = 0.0, y = 0.0, z = 0.0

Note：如果你的代码中有不需要改变的值，请使用 let 关键字将它声明为常量。只将需要改变的值声明为变量。

类型标注

当你声明常量或者变量的时候可以加上类型标注 (type annotation），说明常量或者变量中要存储的值的类型。通过在常量或变量名后面接一个冒号来写一个类型标注，后跟一个空格，后跟要使用的类型的名称。

这个例子给welcomeMessage 变量添加了类型标注，表示这个变量可以存储 String类型的值：

   var welcomeMessage: String

声明中的冒号代表着“xx是xx类型”，所以这行代码可以被理解为：

声明一个类型为 String，名字为welcomeMessage的变量。类型为 String ”的意思是“可以存储任意 String 类型的值。

welcomeMessage 变量现在可以被正确地设置成任意字符串：

  welcomeMessage = "Hello"

你可以在一行中定义多个同样类型的变量，用逗号分割，并在最后一个变量名之后添加类型标注：

  var red, green, blue: Double

Note：一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考类型安全和类型推断。在上面的例子中，没有给 welcomeMessage 赋初始值，所以变量 welcomeMessage 的类型是通过一个类型标注指定的，而不是通过初始值推断的。常量和变量的命名

你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符：

let π = 3.14159
let 你好 = "你好世界"
let  = "dogcow"

常量与变量名不能包含空格，数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。不能以数字开头，但是可以在常量与变量名的其他地方包含数字。一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者改变其存储的值的类型。同时，你也不能将常量与变量进行互转。

Note：如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。你可以更改现有的变量值为其他同类型的值，在下面的例子中，friendlyWelcome的值从"Hello!"改为了"Bonjour!":

var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!"
// friendlyWelcome 现在是 "Bonjour!"

与变量不同，常量的值一旦被确定就不能更改了。尝试这样做会导致编译时报错：

let languageName = "Swift"
languageName = "Swift++"
// 这会报编译时错误 - languageName 不可改变

输出常量和变量

你可以用print(_:separator:terminator:) 函数来输出当前常量或变量的值:

print(friendlyWelcome)// 输出 "Bonjour!"

print(:separator:terminator:)是一个用来输出一个或多个值到适当输出区的全局函数。在 Xcode中，print(:separator:terminator:)将会输出内容到“console”面板上。separator和 terminator参数具有默认值，因此你调用这个函数的时候可以忽略它们。默认情况下，该函数通过添加换行符来结束当前行。如果不想换行，可以传递一个空字符串给 terminator 参数--例如，print(someValue, terminator:"") 。关于参数默认值的更多信息，请参考默认参数值。

Swift 用字符串插值（string interpolation)的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：

print("The current value of friendlyWelcome is \(friendlyWelcome)")
// 输出 "The current value of friendlyWelcome is Bonjour!

Note：字符串插值所有可用的选项，请参考字符串插值。注释

请将你的代码中的非执行文本注释成提示或者笔记以方便你将来阅读。Swift 的编译器将会在编译代码时自动忽略掉注释部分。 Swift 中的注释与 C 语言的注释非常相似。单行注释以双正斜杠 (//) 作为起始标记:

  // 这是一个注释

行注释的起始标记为单个正斜杠后跟随一个星号（/），终止标记为一个星号后跟随单个正斜杠（/）:

/* 这是一个,多行注释 \*/

与 C 语言多行注释不同，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记：

/* 这是第一个多行注释的开头
/* 这是第二个被嵌套的多行注释 \*/
  这是第一个多行注释的结尾 \*/

通过运用嵌套多行注释，你可以方便快速的注释掉一大段代码，即使这段代码之中已经含有了多行注释块。

分号

与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号（;），当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句：

let cat = "";
print(cat)// 输出 ""

整数

整数就是没有小数部分的数字，比如 42和 -23 。整数可以是有符号（正数、零和负数）或者无符号（正数、零）。 Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是UInt8，32位有符号整数类型是Int32。就像 Swift 的其他类型一样，整数类型采用大写命名法。

整数范围

你可以访问不同整数类型的 min 和max 属性来获取对应类型的最小值和最大值：

 let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型
let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型

这些属性的值具有适当大小的数字类型（例如上例中的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长度相同。 Note：尽量不要使用UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用Int，即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推断，请参考类型安全和类型推断。

浮点数

浮点数是有小数部分的数字，比如 3.14159，0.1 和 -273.15。浮点类型比整数类型表示的范围更广，可以存储比Int 类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：

Double表示64位浮点数。 Float表示32位浮点数。 Note：Double精确度很高，至少有15位数字，而Float只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围，在两种类型都可以选择的情况下，将优先选择 Double。

类型安全和类型推断

Swift 是一个类型安全（type-safe）的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String，你绝对不可能错误地传进去一个Int。

由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。

当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。

因为有了类型推断，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。

当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个确定值（literal value 或 literal）即可触发类型推断。（字面量就是会直接出现在你代码中的值，比如 42 和3.14159。）例如，如果你给一个新常量赋值42并且没有标明类型，Swift 可以推断出常量类型是 Int，因为你给它赋的初始值看起来像一个整数：

let meaningOfLife = 42// meaningOfLife 会被推测为 Int 类型

同理，如果你没有给浮点数标明类型，Swift 会推断你想要的是Double：

let pi = 3.14159// pi 会被推测为 Double 类型

当推断浮点数的类型时，Swift 总是会优先选择 Double而不是Float。如果表达式中同时出现了整数和浮点数，会被推断为 Double 类型：

let anotherPi = 3 + 0.14159  // anotherPi 会被推测为 Double 类型

原始值3 没有显式声明类型，而表达式中出现了一个浮点数，所以表达式会被推断为 Double类型。

数值型字面量

整数字面量可以被写作：

一个十进制数，没有前缀一个二进制数，前缀是0b 一个八进制数，前缀是0o 一个十六进制数，前缀是0x 下面的所有整数字面量的十进制值都是17

let decimalInteger = 17
let binaryInteger = 0b10001   // 二进制的17
let octalInteger = 0o21   // 八进制的17
let hexadecimalInteger = 0x11   // 十六进制的17

浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是 0x ）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。十进制浮点数也可以有一个可选的指数（exponent)，通过大写或者小写的 e来指定；十六进制浮点数必须有一个指数，通过大写或者小写的 p来指定。如果一个十进制数的指数为 exp，那这个数相当于基数和10^exp的乘积：

1.25e2 表示 1.25 × 10^2，等于 125.0。
1.25e-2 表示 1.25 × 10^-2，等于 0.0125。

如果一个十六进制数的指数为exp，那这个数相当于基数和2^exp的乘积：

0xFp2 表示 15 × 2^2，等于 60.0。
0xFp-2 表示 15 × 2^-2，等于 3.75。

下面的这些浮点字面量都等于十进制的12.1875：

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

数值型类型转换

通常来讲，即使代码中的整数常量和变量已知非负，也请使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推断。

只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。

整数转换

不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127，而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：

let cannotBeNegative: UInt8 = -1// UInt8 类型不能存储负数，所以会报错
let tooBig: Int8 = Int8.max + 1// Int8 类型不能存储超过最大值的数，所以会报错

由于每种整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使用数值型类型转换。这种选择性使用的方式，可以预防隐式转换的错误并让你的代码中的类型转换意图变得清晰。

为了将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand是UInt16类型，然而常量one是UInt8类型。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算：

  let twoThousand: UInt16 = 2_000
  let one: UInt8 = 1
  let twoThousandAndOne = twoThousand + UInt16(one)

现在两个数字的类型都是 UInt16，可以进行相加。输出常量 twoThousandAndOne 的类型被推断为 UInt16，因为它是两个 UInt16值的和。

SomeType（ofInitialValue）是调用Swift类型的初始化器并传入初始值的默认方式。在语言内部，UInt16有接受一个UInt8的值，这个初始化器用来从现有的UInt8中创建一个新的UInt16。然而，你并不能传入任意类型的值，只能传入UInt16类型的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考扩展。

整数和浮点数转换

整数和浮点数的转换必须显式指定类型：

let three = 3let pointOneFourOneFiveNine = 0.14159 let pi = Double(three) + pointOneFourOneFiveNine // pi 等于 3.14159，所以被推测为 Double 类型这个例子中，常量 three的值被用来创建一个Double类型的值，所以加号两边的数类型须相同。如果不进行转换，两者无法相加。浮点数到整数的反向转换同样行，整数类型可以用` Double 或者Float类型来初始化：

let integerPi = Int(pi)// integerPi 等于 3，所以被推测为 Int 类型当用浮点类型来初始化一个新的整数值时，浮点值会被截断。也就是说 4.75会变成 4，-3.9会变成 -3。

Note：结合数字类常量和变量不同于结合数字类字面量。字面量3可以直接和字面量0.14159相加，因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。

类型别名

类型别名type aliases就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

当你想要给现有类型起一个更合适的名字时，类型别名非常有用。比如你正在处理特定长度的外部资源的数据：

typealias AudioSample = UInt16

定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：

var maxAmplitudeFound = AudioSample.min// maxAmplitudeFound 现在是 0

本例中，AudioSample被定义为UInt16的一个别名。因为它是别名，AudioSample.min实际上是UInt16.min，所以会给maxAmplitudeFound赋一个初值0。

布尔值

Swift 有一个基本的布尔Boolean类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift 有两个布尔常量，true和false：

let orangesAreOrange = truelet
turnipsAreDelicious = false

orangesAreOrange和turnipsAreDelicious 的类型会被推断为 Bool，因为它们的初值是布尔字面量。就像之前提到的 Int 和 Double一样，如果创建变量的时候给它们赋值 true或者false，那你不需要将常量或者变量声明为Bool类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推断，这让 Swift 代码更加简洁并且可读性更高。当你编写条件语句比如 if 语句的时候，布尔值非常有用：

if turnipsAreDelicious {
     print("Mmm, tasty turnips!")
} else {
     print("Eww, turnips are horrible.")
}

// 输出 "Eww, turnips are horrible." 条件语句，例如if，请参考控制流。

如果你在需要使用 Bool类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：

let i = 1if i { // 这个例子不会通过编译，会报错}

然而，下面的例子是合法的：

let i = 1
if i == 1 {
    // 这个例子会编译成功
}

i == 1 的比较结果是 Bool类型，所以第二个例子可以通过类型检查。类似i ==1这样的比较，请参考基本操作符。和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误，并确保特定代码的意图总是清晰的。

元组

元组tuples把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

下面这个例子中，(404, "Not Found")是一个描述 HTTP 状态码HTTP status code的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特定值。如果你请求的网页不存在就会返回一个 404 Not Found 状态码。

let http404Error = (404, "Not Found")
// http404Error 的类型是 (Int, String)，值是 (404, "Not Found")

404, "Not Found"元组把一个 Int 值和一个String值组合起来表示HTTP状态码的两个部分：一个数字和一个人类可读的描述。这个元组被定义为“一个类型为 (Int, String)的元组”。你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。你可以创建任何一个类型为(Int, Int, Int)或者 (String, Bool) 或者其他任何你想要的组合的元组。你可以将一个元组内容分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：

let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// 输出 "The status code is 404"
print("The status message is \(statusMessage)")
// 输出 "The status message is Not Found"

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_ ）表示：

let (justTheStatusCode, \_) = http404Error
print("The status code is \(justTheStatusCode)")
// 输出 "The status code is 404"

此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：

print("The status code is \(http404Error.0)")
// 输出 "The status code is 404"
print("The status message is \(http404Error.≥   1)")
// 输出 "The status message is Not Found"

你可以在定义元组的时候给单个元素命名：

let http200Status = (statusCode: 200, description: "OK")

给元组中的元素命名后，你可以通过名字来获取这些元素的值：

print("The status code is \(http200Status.statusCode)")
// 输出 "The status code is 200"
print("The status message is \(http200Status.description)")
// 输出 "The status message is OK"

作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个(Int, String) 元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考函数参数与返回值。

Note：元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考类和结构体。 The Basics 上半部分完结, 下半部分我们将于明天下午发布.

Previous力学动画 Nextswift 中的KVO用法

Last updated 6 years ago