Swift - 基础部分

常量和变量

• 常量和变量相当于一个容器，存储数据。常量和变量把一个名字名字和一个指定类型的值关联起来。常量的值一旦设定就不能更改，而变量的值可以任意更改。

声明常量和变量

• 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", 1101, 93.2)
var programmingLanguage: (String, (String, String))

programmingLanguage = ("iOS", ("Objective-C", "Swift"))

print(studentInfomation.0) // 输出 Edward
print(studentInfomation.1) // 输出 1101

print(programmingLanguage.0) // 输出 iOS
print(programmingLanguage.1.0) // 输出 Objective-C

• Swift允许将元组的元素拆分成单个的常量或变量，接下来即可正常使用这些常量或变量了。

var studentInfomation = ("Edward", 1101, 93.2)

let (stuName, stuNumber, stuScore) = studentInfomation

print(stuName) // 输出 Edward
print(stuNumber) // 输出 1101
print(stuScore) // 输出 93.2

• 如果程序只需要部分元组的元素，分解的时候可以使用下划线_作为被忽略部分的占位符。

var studentInfomation = ("Edward", 1101, 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, isNoMoney: Bool, isNoTime: 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讲义》