闭区间运算符（a...b）定义一个包含从 a 到 b（包括 a 和 b）的所有值的区间。a 的值不能超过 b。
半开区间运算符（a..<b）定义一个从 a 到 b 但不包括 b 的区间。
单侧区间运算符（a.../...b）可以表达往一侧无限延伸的区间
2.4 字符与字符串
Swift 的 String 和 Character 类型提供了一种快速且兼容 Unicode 的方式来处理代码中的文本内容, 因此可以用任何字符。有趣的是，变量或者常量命名可以采用emoji表情或者汉字。
for character in "Dog!🐶" {
print(character)
}
// D
// o
// g
// !
// 🐶在书中介绍了String是基于 Unicode 标量 建立的. 因此需要了解一下Unicode中的码点, utf-8等概念. 在说到 count和objective-c的length返回的值不一样, 也是由于采取的编码格式不同.
String是值类型，对于String的使用不再赘述。
2.4 控制流
1）if
if的条件必须是一个布尔表达式——这意味着像 if score { ... } 这样的直接传值的代码将报错，swift不会隐形地与 0 做对比。
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
// swift的if语句可以像其他编程语言的一样，格式一样
// 可以采用之前的写法
if (score > 50) {
// ...
}
// 也可以不写括号，裸奔~
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
print(teamScore)
// guard语句对比：相当于if 相反的执行
if 条件为真 {
// 执行
}
guard 条件为真else {
// 执行
}
// guard也可以进行可选绑定
let str : String?;
guard let value = str else {
//解绑失败，即数据为空进入
}2）switch
switch 支持任意类型的数据（区间、元组…………）以及各种比较操作——不仅仅是整数以及测试相等。
case还支持多个条件
let vegetable = "red pepper"
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
print("Is it a spicy \(x)?")
default:
print("Everything tastes good in soup.")
}在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止 switch 语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用 break 语句。如果需要产生case穿透，则可以在case结束后，增加fallthrough
2.5 函数
1）函数的定义
// 定义格式
func funcName(parameters) -> returnType {
function body
}
// 例子
func greet(person: String) -> String {
let greeting = "Hello, " + person + "!"
return greeting
}这里函数的格式类似JavaScript的格式，只是多了返回值类型
2）参数列表
这里重点说明参数列表。
a）参数标签和参数名称：每个函数参数都有一个_参数标签（argument label）以及一个_参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，参数名称来作为它们的参数标签。
// 参数列表
func someFunction(parameterName: Int) {
// 在函数体内，parameterName 代表参数值
}b）如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)c）当然也可以类似C++使用缺省参数，即就是提供默认值
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
// 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6)
// parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4)
// parameterWithDefault = 12d）当然你还可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。
func arithmeticMean(_ numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。e）函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为_输入输出参数_
定义一个输入输出参数时，在参数定义前加 inout 关键字，且这个值需要时变量而不是常量
当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}3）函数类型
函数类型就像是函数指针一样。实则，还是那句话"万物皆对象"。
在 Swift 中，每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。使用函数类型就像使用其他类型一样。
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
return a * b
}
var mathFunction: (Int, Int) -> Int = addTwoInts函数类型可以作为参数类型，返回值类型等。
2.6 闭包
1) 闭包简介
OC有Block，C++有lambda表达式，swift则有闭包。
闭包采用如下三种形式之一：
- 全局函数是一个有名字但不会捕获任何值的闭包
- 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
- 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
闭包的语法
{ (parameters) -> return type in
statements
}
// 使用
var blockOne:(String, Int) = {(parma1:String, parma2:Int) -> void in
}// 还有很多精巧的语法
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
// 单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
// 直接通过 $0，$1，$2 来顺序调用闭包的参数，以此类推。
reversedNames = names.sorted(by: { $0 > $1 } )
// Swift 的 String 类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值
reversedNames = names.sorted(by: >)另外要注意的是闭包表达式是引用类型。
2) 逃逸闭包
当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。
// @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}3)尾随闭包
如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以将闭包书写在函数圆括号之后，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签
func someFunctionThatTakesAClosure(closure: () -> Void) {
// 函数体部分
}
func mySug() {
// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(closure: {
// 闭包主体部分
})
// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
// 闭包主体部分
}
}2.7 枚举、结构体、类
1）枚举
Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。
// 枚举的定义
enum SomeEnumeration {
// 枚举定义放在这里
// 使用 case 关键字来定义一个新的枚举成员值。
}
// 枚举的定义例子
enum CompassPoint {
case north
case south
case east
case west
}
// 可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。
enum Barcode {
case upc(Int, Int, Int, Int)
case qrCode(String)
}
// 枚举的遍历
enum TestEnum:CaseIterable {
}
for item in TestEnum.allCases {
}2）结构体与类
定义语法：
struct SomeStructure {
// 在这里定义结构体
}
class SomeClass {
// 在这里定义类
}
// 结构体是值类型
// 类是引用类型
// 结构体也可以当类来使用，但是不建议
// 还要很多相同点, 但是class就是定义类的, 不过多赘述struct注意：
- 继承允许一个类继承另一个类的特征
- 类型转换允许在运行时检查和解释一个类实例的类型
- 析构器允许一个类实例释放任何其所被分配的资源
- 引用计数允许对一个类的多次引用
3）类的属性与方法
a）属性
swift中类的属性分为存储属性与计算属性。
存储属性就是存储在特定类或结构体实例里的一个常量或变量。
class FixedLengthRange {
var firstValue: Int
let length: Int
}计算属性就是不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。
struct Point {
var x = 0.0, y = 0.0
}
struct Size {
var width = 0.0, height = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
var center: Point {
get {
let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY)
}
set(newCenter) {
origin.x = newCenter.x - (size.width / 2)
origin.y = newCenter.y - (size.height / 2)
}
}
}swift还有一个类属性，类似C++的static成员。
使用关键字 static 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 class 来支持子类对父类的实现进行重写。
struct SomeStructure {
static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int {
return 1
}
}
enum SomeEnumeration {
static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int {
return 6
}
}
class SomeClass {
static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int {
return 27
}
class var overrideableComputedTypeProperty: Int {
return 107
}
}b）方法
实例方法同普通方法一样，方法体可以使用self关键字
类方法在方法的 func 关键字之前加上关键字 static，来指定类型方法。类还可以用关键字 class 来指定，从而允许子类重写父类该方法的实现。
2.8 类的构造与析构
1）基础说明
类的构造与析构和C++的构造与析构类似，唯一不同的可能就是在语法上不同了。
比如：全缺省构造，默认构造等等。
列出几个比较重要的构造函数语法：
// 默认构造
init() {
// 在构造函数中，如果没有明企鹅super.init()，那么系统会自动添加
// 使用KVC构造时，一定要先super.init()
}
// 参数构造
init(parmaterNmae : type) {
// 有歧义则加self
self.xxx = parmaterNmae;
}
init?(parmaterNmae : type){
// 可能返回空，获取时为可选类型
}
// 必要构造
required init(parmaterNmae : type) {
}下面挨个举例：
class Color {
let red, green, blue: Double
init () {
// 默认构造
}
init(red: Double, green: Double, blue: Double) {
// 逐一成员构造器
self.red = red
self.green = green
self.blue = blue
}
init(white: Double) {
// 形参构造：同函数的参数标签一样
red = white
green = white
blue = white
}
}2）构造代理
构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能避免多个构造器间的代码重复。在《effective OC2.0》中也说到，在设置构造函数的时候，提供一个基础构造方法，共其他构造使用。
由于结构体以及枚举为值类型，无法继承，它们只能代理给自己的其它构造器。
struct Rect {
var origin = Point()
var size = Size()
init() {}
init(origin: Point, size: Size) {
self.origin = origin
self.size = size
}
init(center: Point, size: Size) {
let originX = center.x - (size.width / 2)
let originY = center.y - (size.height / 2)
self.init(origin: Point(x: originX, y: originY), size: size)
}
}类则不同，它可以继承自其它类。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。
针对类的构造器，有两种，就是指定构造器和便利构造器。(swift针对构造器的设计是真的够啰嗦的)。
简单总结下：
如果一个类是基类，那么构造器就和前面一样写就可以，未初始化的属性一定要初始化。
重点是不是基类的情况：
子类的指定构造器一定要先初始化自己类中的属性，然后再调用父类的指定构造器。重写同理。
便利构造器就是你可以提供简化一下参数，然后调用类中的指定构造器。
类是不继承构造器的。如果触发以下情况，会自动继承：
- 前提是你为子类中引入的所有新属性都提供了默认值
- 如果子类没有定义任何指定构造器，它将自动继承父类所有的指定构造器。
- 如果子类提供了所有父类指定构造器的实现——无论是通过规则 1 继承过来的，还是提供了自定义实现——它将自动继承父类所有的便利构造器。
3）可失败构造
给构造器传入无效的形参，或缺少某种所需的外部资源，又或是不满足某种必要的条件的时候可以构造失败。
class Document {
var name: String?
// 该构造器创建了一个 name 属性的值为 nil 的 document 实例
init() {}
// 该构造器创建了一个 name 属性的值为非空字符串的 document 实例
init?(name: String) {
if name.isEmpty { return nil }
self.name = name
}
}4）必要构造器
在类的构造器前添加 required 修饰符表明所有该类的子类都必须实现该构造器
class SomeClass {
required init() {
// 构造器的实现代码
}
}
// 在子类重写父类的必要构造器时，必须在子类的构造器前也添加 required 修饰符
// 表明该构造器要求也应用于继承链后面的子类。
// 在重写父类中必要的指定构造器时，不需要添加 override 修饰符
class SomeSubclass: SomeClass {
required init() {
// 构造器的实现代码
}
}5）析构
析构器只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字 deinit 来标示，类似于构造器要用 init 来标示。
deinit {
// 执行析构过程
}2.9 属性监听器
class SomeClass : NSObject {
var name : String {
// 属性即将改变
willSet {
}
// 属性已经改变
didSet {
}
}
}
// 即使设置相同的值仍会触发
// 不能同setter同时存在
//2.10 类的继承
面向对象语言的三大特性之一继承，作为复用代码的一种手段，在swift中也是一样。swift和OC不一样，OC中所有的类都是都是基于NSObject的。但是Swift 中的类并不是从一个通用的基类继承而来的。如果你不为自己定义的类指定一个超类的话，这个类就会自动成为基类。
继承的基础语法：
class SomeClass: SomeSuperclass {
// 这里是子类的定义
}举个例子：
// 父类
class Vehicle {
var currentSpeed = 0.0
var description: String {
return "traveling at \(currentSpeed) miles per hour"
}
func makeNoise() {
// 什么也不做——因为车辆不一定会有噪音
}
}
// 子类
class Bicycle: Vehicle {
var hasBasket = false
}重写
// 重写
// 重写某个特性，你需要在重写定义的前面加上 override 关键字。
class Train: Vehicle {
