常量和变量
- 常量和变量相当于一个容器，存储数据。常量和变量把一个名字名字和一个指定类型的值关联起来。常量的值一旦设定就不能更改，而变量的值可以任意更改。
声明常量和变量
Swift是强类型的语言，要求所有的常量和变量必须先声明，后使用，声明变量时必须显示或隐式指定变量的类型。
Swift用
let来声明常量，用var来声明变量。
// 声明常量
let studentNumber = 1101
// 声明变量
var studentName = "Edward"
// 常量允许被修改
studentName = "Petter"
- 在一行中声明多个常量或变量，用逗号隔开：
var x = 0.0,y = 0.0,z = 0.0
注意：如果你的代码中有不需要改变的值，请使用
let关键字将它声明为常量。只将需要改变的值声明为变量。
类型标注
- 声明常量或变量时可加上类型标注，说明常量或变量中要存储的值的类型，程序要么通过
let/var 变量名 ：类型的形式显示指定该常量或变量的类型，要么为该常量或变量指定初始值—Swift编译器将会根据该初始值确定常量或变量的类型。
// 显示指定类型
let age: Int = 21 // Int
var name: String // String
// 隐式指定类型
var zipCode = 610000 // Int
let address = "ChengDu" // String
注意：声明常量时必须指定初始值，这是由于常量不允许被重新赋值；一般来说，常量或变量很少需要写类型标注，如果你在声明常量或变量时赋了初始值，系统会自动推断该常量或变量的类型。
常量和变量的命名
- Swift允许使用任何字符作为常量或变量名，包括Unicode码。但是不允许包含数学符号、箭头、非法字符、连线与制表符，也不能以数字开头。
let π = 3.1415926
var 姓名 = "Edward"
var �� = "dogName_Akitas"
输出常量和变量
- Swift使用
print(_:)函数来输出常量和变量。
print(姓名) // 输出 Edward
print("Hello,word!") // 输出 Hello,word!
print("He's name is '\(姓名)'.") // 输出 He's name is 'Edward'.
注释
- 单行注释
// 这是一个当行注释
- 多行注释
/* 这是一个 多行注释 */
- 嵌套注释
/* 这是第一个多行注释的开头 /* 这是第二个被嵌套的多行注释 */ 这是第一个多行注释的结尾 */
分号
- Swift不强制要求每条语句必须以
;结尾，但如果要在一行内写多条独立语句，则需要以;隔开。
let phonesystem = "iOS"; print("The mobile phone system is '\(phonesystem)'.")
整形
整数就是没有小数部分的数字，比如
42和-23。整数可以是有符号(正、负、零)或者无符号(正、零)。Swift允许使用
max或min访问对应类型的最大值或最小值。Swift提供了一个特殊的整数类型
Int，长度与当前平台的原生字长相同。
浮点型
浮点数是有小数部分的数字，比如
3.14159,0.1和-273.15。-
浮点类型比整数类型表示的范围更大，可以存储比
Int类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。Float表示32位浮点数。精度要求不高的话可以使用此类型。
类型安全和类型推断
Swift是一个类型安全的语言，类型安全的语言明确了常量或变量的类型，如果声明的变量为
String类型，则绝对不能赋值一个Int类型的值。由于Swift是类型安全的，所以它会在编译你的代码时进行类型检查，并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需 要显式指定类型。如果你没有显式指定类型，Swift会使用_类型推断来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单,只要检查你赋的值即可。
因为有了类型推断，所以很少需要声明类型。
类型别名
- 类型别名就是给现有类型定义另一个名字。你可以使用
typealias关键字来定义类型别名，其格式为：typealias 类型别名 = 已有类型
typealias MyString = String
var variable: MyString // variable为MyString类型即String类型，因此只能赋字符串
布尔型
Swift有一个基本的布尔类型，叫做
Bool，用于表示逻辑上的“真”或“假”，其提供了两个布尔常量：true和false。Bool类型的值或变量主要用作旗标来进行流程控制
let isLogin: Bool = true
if isLogin == true {
print("已登录！")
}else {
print("未登录")
}
// 输出 已登录！
-
Bool类型的值或变量也可用于三目运算符
let isLogin: Bool = true
isLogin == true ? print("已登录！") : print("未登录")
// 输出 已登录！
- 如果程序在使用
Bool类型的地方使用了非Bool值，Swift的类型检查机制会报错。
var i = 1
if i {
// 这个例子不能通过编译，会报错
}
var i = 1
if i == 1 {
// 这个例子会编译成功
}
// i == 1的比较结果是Bool类型,所以第二个例子可以通过类型检查
元组
-
元组使用圆括号
()把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
定义元组类型的变量
// 定义元组变量，并指定初始值，系统推断该元组类型为：(String,Int,Double)
var studentInfomation = ("Edward",1101,93.2)
// 使用元组类型定义元组变量
var score: (String,Double)
// 为元组变量赋值时必须为所有成员都指定值
score = ("语文",98.5)
- Swift允许元组的成员可以再次是元组
var programmingLanguage: (String,(String,String))
programmingLanguage = ("iOS",("Objective-C","Swift"))
获取元组中的元素值
- Swift允许通过下标来访问元组的单个元素，元组的下标从0开始，元组的第1个元素的下标为0，第2个元素的下标为1……以此类推。
var studentInfomation = ("Edward",93.2)
var programmingLanguage: (String,(String,String))
programmingLanguage = ("iOS","Swift"))
print(studentInfomation.0) // 输出 Edward
print(studentInfomation.1) // 输出 1101
print(programmingLanguage.0) // 输出 iOS
print(programmingLanguage.1.0) // 输出 Objective-C
- Swift允许将元组的元素拆分成单个的常量或变量，接下来即可正常使用这些常量或变量了。
var studentInfomation = ("Edward",93.2)
let (stuName,stuNumber,stuscore) = studentInfomation
print(stuName) // 输出 Edward
print(stuNumber) // 输出 1101
print(stuscore) // 输出 93.2
- 如果程序只需要部分元组的元素，分解的时候可以使用下划线
_作为被忽略部分的占位符。
var studentInfomation = ("Edward",93.2)
let (stuName,_,_) = studentInfomation
print("student's name is '\(stuName)'.") // 输出 student's name is 'Edward'.
为元组中的元素命名
- Swift允许在定义元组时给单个元素命名，命名之后，即可通过名字来获取相应元素值。
var 个人信息 = (姓名: "Charles",phoneNumber: 13219038892)
print("\(个人信息.姓名)的手机号码是：\(个人信息.phoneNumber)")
// 输出 Charles的手机号码是：13219038892
可选类型
可选和nil
- 在任何已有类型的后面紧跟
?即可代表可选类型，可选类型的变量用于处理“值缺失”的情况。可选类型表示：
有值，等于 x
或者
无值，等于 nil
- 例子，Swift的
String类型有一个叫做Int()的方法，作用是将一个String值转换成一个Int值。然而，并不是所有的字符串都可以转换成一个整数。字符串"123"可以被转换成数字123，但是字符串abc不行。
let possibleNumber = "123"
// convertednumber 被推测为类型 "Int?",或者类型 "optional Int"
let convertednumber = Int(possibleNumber)
print(convertednumber) // 输出 Optional(123)
// 如果possibleNumber的值为"abc"，则convertednumber输出nil。
- Swift使用
nil代表“值缺失”，因此上面的例子中当possibleNumber的值为”abc”时，convertednumber会输出nil。
注意：只有可选类型的变量或常量才能接受
nil，非可选类型的常量或变量不能接受nil。如果声明一个可选常量或变量但是没有赋值，系统会自动将其置为nil。
let a: Int = nil; // Int类型不能置为nil，程序报错
let b: Int? = nil; // Int?可选类型允许置为nil
if语句以及强制解析
- Swift允许使用
if语句和nil比较来判断一个可选值是否包含值。你可以使用“相等”（==）或“不等”（!=）来执行比较。Int?类型与Int类型并不是相同的类型，程序不能直接把Int?类型的变量或常量当成Int类型的变量或常量使用，当你确定可选类型确实包含值之后，可在可选类型变量或常量后添加英文感叹号!进行强制解析。
let roomNumber: Int? = 1101
if roomNumber == nil {
print("当前无房间！")
}else {
print("当前有房间，房间号为：\(roomNumber!)")
}
// 输出 当前有房间，房间号为：1101
注意：Swift的强制解析是有前提的：必须可选类型的变量或常量确实有值才能解析成功。使用
!来获取一个不存在的可选值会导致运行时错误。
可选绑定
- 可选绑定用于判断可选类型的变量或常量是否有值，如果可选类型的变量或常量有值就赋给另一个临时的变量或常量。
var str = "123"
if var temp = Int(str) {
print("转换成功，其值为：\(temp)")
}else{
print("转换失败！")
}
// 输出 转换成功，其值为：123
隐式可选类型
可选类型暗示了常量或者变量可以“没有值”。可选可以通过
if语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
这种类型的可选状态被定义为隐式解析可选类型。把想要用作可选的类型的后面的问号(
String?)改成感叹号(String!)来声明一个隐式解析可选类型。当可选类型被第一次赋值之后就可以确定之后一直有值的时候,隐式解析可选类型非常有用。隐式解析可选类型 主要被用在 Swift 中类的构造过程中。
一个隐式解析可选类型其实就是一个普通的可选类型,但是可以被当做非可选类型来使用,并不需要每次都使用 解析来获取可选值。
隐式可选类型与显示可选类型用法一致，区别在于对数据的解析，如
String?与String!的区别在于：当程序需要获取String?的变量或常量的值时，程序必须在变量或常量后面添加!后缀执行强制解析；但当程序需要获取String!类型的变量或常量的值时，无需在变量或常量后添加!后缀执行强制解析。
var phoneType: String! = "iPhone"
print(phoneType) // 输出 iPhone， 无需使用 ! 进行强制解析
注意： 如果一个变量之后可能变成
nil的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。
Guard语句
guard语句和if语句有点类似，都是根据其关键字之后的表达式的布尔值决定下一步执行什么。但与if语句不同的是，guard语句只会有一个代码块，不像if语句可以if else多个代码块。guard语句判断其后的表达式布尔值为false时，才会执行之后代码块里的代码，如果为true，则跳过整个guard语句。
举例分析
- 我们以今年高考为例，在进入考场时一般都会检查身份证和准考证，我们写这样一个方法：
func checkup(person: [String: String!]) {
// 检查身份证，如果身份证没带，则不能进入考场
guard let id = person["id"] else {
print("没有身份证，不能进入考场!")
return
}
// 检查准考证，如果准考证没带，则不能进入考场
guard let examNumber = person["examNumber"] else {
print("没有准考证，不能进入考场!")
return
}
// 身份证和准考证齐全，方可进入考场
print("您的身份证号为:\(id)，准考证号为:\(examNumber)，请进入考场!")
}
checkup(["id": "1101"]) // 输出 没有准考证，不能进入考场!
checkup(["examNumber": "S1101"]) // 输出 没有身份证，不能进入考场!
checkup(["id": "1101","examNumber": "S1101"]) // 输出 您的身份证号为:1101，准考证号为:S1101，请进入考场!
上述代码中的第一个
guard语句用于检查身份证，如果检查到身份证没带，也就是表达式为false时，执行大括号里的代码，并返回。第二个guard语句则检查准考证。如果两证齐全，则执行最后一个打印语句，上面的两个
guard语句大括号内的代码都不会执行，因为他们表达式的布尔值都是true。这里值得注意的是，
id和examNumber可以在guard语句之外使用，也就是说当guard对其表达式进行验证后，id和examNumber可在整个方法的作用域中使用，并且是解包后的。
guard与if语句的区别
guard必须强制有else语句只有在
guard审查的条件成立，guard之后的代码才会运行 (像守卫一样，条件不符就不让过去)。
错误处理
错误处理主要用于应对程序执行中出错的条件。相对于可选中运用值的存在与缺失来表达函数的成功与失败，错误处理可以推断失败的原因，并传送至程序的其他部分。
当一个函数遇到错误条件，它能报错。调用函数的地方能抛出错误消息并合理处理。
func canThrowAnErrow() throws{
//this function may or may not throw an error
}
-
一个函数可以通过在声明中添加
throws关键词来抛出错误消息。当你的函数能抛出错误消息时，你应该在表达式中前置try关键词。
do {
try canThrowAnErrow()
// 没有错误消息抛出
} catch {
// 有一个错误消息抛出
}
-
一个
do的声明创建了一个新的包含作用域，使得错误能被传播到一个或更多catch从句。
举例分析
如何建造异常类型？
- 在Swift中，如果想要抛出错误，那么抛出的对象必须遵守ErrorType协议，enum枚举是建立异常类型的最好方法。
// 出去玩可能被导致去不了的原因
enum PlayError: ErrorType {
case NoGoodWeather // 没有好天气
case NoMoney // 没有钱
case NoTime // 没有时间
case nopartner // 没有伙伴
}
如何抛出异常？
- 在抛出异常之前，我们需要在函数或方法的返回箭头
->前使用throws来标明将会抛出异常，并在函数或者方法里使用throw扔出异常即可。
// 检查导致不能出去玩的原因是否存在
func checkIsPlay(isNoGoodWeather: Bool,isNoMoney: Bool,isNoTime: Bool,isnopartner: Bool) throws {
guard isNoGoodWeather else {
throw PlayError.NoGoodWeather
}
guard isNoMoney else {
throw PlayError.NoMoney
}
guard isNoTime else {
throw PlayError.NoTime
}
guard isnopartner else {
throw PlayError.nopartner
}
}
- 上面这段代码使用了
guard来进行unwrap optional value。
如何获取并处理异常？
- 使用
do-catch机制获取和处理异常
func Play(isNoGoodWeather: Bool,isnopartner: Bool) {
do {
try checkIsPlay(isNoGoodWeather,isNoMoney: isNoMoney,isNoTime: isNoTime,isnopartner: isnopartner)
print("随便耍！")
}catch PlayError.NoGoodWeather {
print("天气不好，不去耍了！")
}catch PlayError.NoMoney {
print("没有钱，不去耍了！")
}catch PlayError.NoTime {
print("没有时间，不去耍了！")
}catch PlayError.nopartner {
print("没人陪我，不去耍了！")
}catch {
print("见鬼了")
}
}
- 这个
do-catch语句和switch语句有一些相似之处，被捕获的错误详尽无遗，因此你可以使用这种样式来捕获抛出的错误。还要注意关键字try的使用。它是为了明确地标示抛出的代码行，因此当阅读代码的时候，你能够立刻找到错误在哪里。
不处理异常
- 如果我不想处理异常怎么办，或者说，我非常确定某个方法或者函数虽然声明会抛出异常，但是我自己知道我在使用时候是绝对不会抛出任何异常的。这种情况下 我们可以使用
try!。
断言
断言简介与使用
断言会在运行时判断一个逻辑条件是否为
true。如果条件判断为true，代码运行会继续进行；如果条件判断为false，代码运行停止，你的应用被终止。可以使用
assert函数来写一个断言。向assert函数传入一个结果为true或者false的表达式以及一条信息，当表达式为false的时候这条信息会被显示：
let age = 16
assert(age >= 18,"有未成年人进入网吧！") // 因为age < 18，程序奔溃！
何时使用断言？
当条件可能为假时使用断言,但是最终一定要保证条件为真,这样你的代码才能继续运行。断言的适用情景:
整数类型的下标索引被传入一个自定义下标脚本实现,但是下标索引值可能太小或者太大。
需要给函数传入一个值,但是非法的值可能导致函数不能正常执行。
一个可选值现在是
nil,但是后面的代码运行需要一个非nil值。
注意：断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而,在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。
参考网址：
http://wiki.jikexueyuan.com/project/swift/
http://www.cocoachina.com/swift/20150619/12186.html
参考资料：《疯狂Swift讲义》