iOS之Swift基础部分

前言：

        Swift是一门开发iOS、macOS、watchOS和tvOS应用的语言。然后，当你有C或Objective-C开发经验，你会发现Swift的很多内容都是你所熟悉的。

        Swift包含了C和Objective-C上所有的基础数据类型，Int表示整型值；Double和Float表示浮点型值；Bool是布尔型值；String是文本型，Swift还提供了三个基本的集合类型，Array、Set和Dictionary。

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

        除了我们熟悉的类型，Swift 还增加了 Objective-C 中没有的高阶数据类型比如元组（Tuple）。元组可以让你创建或者传递一组数据，比如作为函数的返回值时，你可以用一个元组可以返回多个值。

        Swift 还增加了可选（Optional）类型，用于处理值缺失的情况。可选表示 “那儿有一个值，并且它等于 x ” 或者 “那儿没有值” 。可选有点像在 Objective-C 中使用 nil ，但是它可以用在任何类型上，不仅仅是类。可选类型比 Objective-C 中的 nil 指针更加安全也更具表现力，它是 Swift 许多强大特性的重要组成部分。

        Swift 是一门类型安全的语言，这意味着 Swift 可以让你清楚地知道值的类型。如果你的代码需要一个 String ，类型安全会阻止你不小心传入一个 Int 。同样的，如果你的代码需要一个 String，类型安全会阻止你意外传入一个可选的 String 。类型安全可以帮助你在开发阶段尽早发现并修正错误。

常量和变量

        常量和变量把一个名字和一个指定类型的值关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。

声明常量和变量

        常量和变量必须在使用前声明，用 let 来声明常量，用 var 来声明变量。

let maxNumber = 10

var number = 0

        上面两行代码可以被理解为：声明了一个名字是maxNumber的常量，并给它一个值10。然后，声明一个名字是number的变量并将它的值初始化为0。

        你也可以在一行中声明多个常量或者多个变量，用逗号隔开:

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

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

类型注解

        当你声明常量或者变量的时候可以加上类型注解（type annotation），说明常量或者变量中要存储的值的类型。如果要添加类型注解，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。例：

var name: String

        声明中的冒号代表着“是...类型”，所以这行代码可以被理解为：“声明一个类型为String，名字为name的变量”，“类型为String”的意思是“可以存储任意String类型的值”。name变量现在可以被设置为任意的字符串：

name = "张三"

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

var red, green, blue: Double

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

常量和变量的命名

        常量和变量名可以包含几乎所有的字符，包括 Unicode 字符：

let π = 3.141592

let 你好 = "你好世界"

let = "dog"

        常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode码，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字。

        一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者改变其存储的值的类型。同时，你也不能将常量与变量进行互转。

        注：如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用（`init`）。无论如何，你应当避免使用关键字作为常量或变量名。

        你可以更改现有的变量值为其他同类型的值,与变量不同，常量的值一旦被确定就不能更改了，尝试这样做会导致编译时报错。

var name = "张三"

name = "李四"

let age = 22

age = 23

//这会报编译时错误 - age 不可改变

输出常量和变量

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

print(name)

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

注释

        将你的代码中的非执行文本注释成提示或者笔记以方便你将来阅读。Swift 的编译器将会在编译代码时自动忽略掉注释部分。注释分为以下：

        单行注释以双正斜杠（//）作为起始标记

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

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

// 这是一个单行注释

/* 这也是一个注释，

但是是多行的 */

/* 这是第一个多行注释的开头

/* 这是第二个被嵌套的多行注释 */

这是第一个多行注释的结尾 */

分号

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

let name = "张三"；print(name)

整数

        整数就是没有小数部分的数字，整数可以是有符号（正、负、零）或者无符号（正、零）。 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 类型

        min和max所传回值的类型，正是其所对的整数类型（如上例 UInt8, 所传回的类型是 UInt8），可用在表达式中相同类型值旁。

Int

        一般来说，你不需要专门指定整数的长度。Swift提供了一个特殊的整数类型Int，长度与当前平台的原生字长相同：

        *在32位平台上，Int 和 Int32 长度相同。

        *在64位平台上，Int 和 Int64 长度相同。

UInt

        Swift 也提供了一个特殊的无符号类型 UInt，长度与当前平台的原生字长相同:

         *在32位平台上，UInt 和 UInt32 长度相同。

        *在64位平台上，UInt 和 UInt64 长度相同。

浮点数

        浮点数是有小数部分的数字。浮点类型比整数类型表示的范围更大，可以存储比Int类型更大或者更小的数字。

        Swift 提供了两种有符号浮点数类型：

        *Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。

        *Float表示32位浮点数。精度要求不高的话可以使用此类型。

类型安全和类型推断

        从前言我们就知道，Swift 是一个类型安全的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。例如你的代码需要一个String，你绝对不可能不小心传进去一个 Int。

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

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

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

        当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个字面量即可触发类型推断。

数值型字面量

        整数字面量可以被写作：

        *一个十进制数，没有前缀

        *一个二进制数，前缀是 0b

        *一个八进制数，前缀是 0o

        *一个十六进制数，前缀是 0x

        下面我们来举个例子，表示十进制的17：

let decimalInteger = 17

let binaryInteger = 0b10001 // 二进制的17

let octalInteger = 0o21 // 八进制的17

let hexadecimalInteger = 0x11 // 十六进制的17

整数转换

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

let one: UInt16 = 2000

let two: UInt8 = 1

let number = one + UInt16(one)

整数和浮点数转换

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

let three = 3

let point = 0.14159

let pi = Double(three) + point

let integerPi = Int(pi)   //integerPi 等于 3，所以被推测为 Int 类型

类型别名

        类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用 typealias 关键字来定义类型别名。当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：

typealias AudioSample = UInt16

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

布尔值

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

let isShow = true

let isHidden = false

元组

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

        你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。

        你可以将一个元组的内容分解（decompose）成单独的常量和变量。

        如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记。此外，你还可以通过下标来访问元组中的单个元素，下标从零开始。

        你可以在定义元组的时候给单个元素命名，给元组中的元素命名后，你可以通过名字来获取这些元素的值。例：

let http404Error = (404, "Not Found")

let (statusCode, statusMessage) = http404Error

let (justTheStatusCode, _) = http404Error

let code = http404Error.0

let message = http404Error.1

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

print("The code is \(http200Status.statusCode)")

print("The message is \(http200Status.description)")

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

可选类型

        使用可选类型（optionals）来处理值可能缺失的情况。可选类型表示两种可能： 或者有值， 你可以解析可选类型访问这个值， 或者根本没有值。

nil

        你可以给可选变量赋值为 nil 来表示它没有值。如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil。

var serverResponseCode: Int? = 404    // serverResponseCode 包含一个可选的 Int 值 404

serverResponseCode = nil    // serverResponseCode 现在不包含值

var surveyAnswer: String?    // surveyAnswer 被自动设置为 nil

        注：1.nil 不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。

        2.Swift 的 nil 和 Objective-C 中的 nil 并不一样。在 Objective-C 中，nil 是一个指向不存在对象的指针。在 Swift 中，nil 不是指针,它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为 nil，不只是对象类型。

if 语句以及强制解析

        你可以使用 if 语句和 nil 比较来判断一个可选值是否包含值。你可以使用“相等”(==)或“不等”(!=)来执行比较。如果可选类型有值，它将不等于 nil。

        当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个!表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析（forced unwrapping）

let numberStr = "123"

let number  = Int(numberStr)

if number != nil {

    print("number contains some integer value.")

}

// 输出“number contains some integer value.”

if number != nil {

    print("number has an integer value of \(number!).")

}

// 输出“number has an integer value of 123.”

可选绑定

        使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在 if 和 while 语句中，这条语句不仅可以用来判断可选类型中是否有值，同时可以将可选类型中的值赋给一个常量或者变量。例：

if let num = Int(numberStr) {

    print("\'\(numberStr)\' has an integer value of \(num)")

} else {

    print("\'\(numberStr)\' could not be converted to an integer")

}

// 输出“'123' has an integer value of 123”

        注：在 if 条件语句中使用常量和变量来创建一个可选绑定，仅在 if 语句的句中（body）中才能获取到值。相反，在 guard 语句中使用常量和变量来创建一个可选绑定，仅在 guard 语句外且在语句后才能获取到值。