基础

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

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

if 语句以及强制解析：可以使用 if 语句和 nil 比较来判断一个可选值是否包含值，可以使用“相等”(==)或“不等”(!=)来执行比较，如果可选类型有值，它将不等于 nil，当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析。

注意：使用 ! 来获取一个不存在的可选值会导致运行时错误。使用 ! 来强制解析值之前，一定要确定可选包含一个非 nil 的值。

使用断言进行调试:

letage = -3assert(age >=0,"A person's age cannot be less than zero")// 因为 age < 0，所以断言会触发;

如果不需要断言信息，可以就像这样忽略掉：assert(age >=0)

空合运算符（a ?? b）将对可选类型 a 进行空判断，如果 a 包含一个值就进行解封，否则就返回一个默认值 b。表达式 a 必须是 Optional 类型。默认值 b 的类型必须要和 a 存储值的类型保持一致。  （a !=nil ? a! : b）

闭区间运算符（a...b）定义一个包含从 a 到 b（包括 a 和 b）的所有值的区间。a 的值不能超过 b。 ‌forindexin1...5{ }

半开区间运算符（a..半开区间，是因为该区间包含第一个值而不包括最后的值，foriin0..<5{}

单侧区间，可以表达往一侧无限延伸的区间，for name in names[2...] { }

varemptyString =""      // 空字符串字面量

varanotherEmptyString =String()   // 初始化方法       // 两个字符串均为空并等价。

可以通过检查其Bool类型的isEmpty属性来判断该字符串是否为空：

ifemptyString.isEmpty {print("Nothing to see here")}

数组：varsomeInts = [Int]()      someInts.append(3)

创建一个带有默认值的数组：varthreeDoubles =Array(repeating:0.0,count:3)

varshoppingList: [String] = ["Eggs","Milk"]  或者  varshoppingList = ["Eggs","Milk"]

使用布尔属性isEmpty作为一个缩写形式去检查count属性是否为0：ifshoppingList.isEmpty{}

使用append(_:)方法在数组后面添加新的数据项：shoppingList.append("Flour")

插入：shoppingList.insert("Maple Syrup", at:0)

移除：letmapleSyrup = shoppingList.remove(at:0)

移除最后一项：letapples = shoppingList.removeLast()

遍历：foriteminshoppingList {print(item)}

for (index, value) in shoppingList. enumerated() {print("Item\(String(index +1)):\(value)")}

字典：varnamesOfIntegers = [Int:String]()  // 它的键是Int型，值是String型

namesOfIntegers[16] ="sixteen"  // namesOfIntegers 现在包含一个键值对

namesOfIntegers = [:]  // namesOfIntegers 又成为了一个 [Int: String] 类型的空字典

varairports: [String:String] = ["YYZ":"Toronto Pearson","DUB":"Dublin"]

varairports = ["YYZ":"Toronto Pearson","DUB":"Dublin"] //和数组一样，我们在用字典字面量构造字典时，如果它的键和值都有各自一致的类型，那么就不必写出字典的类型

和数组一样，我们可以通过字典的只读属性count来获取某个字典的数据项数量：ifairports.isEmpty{}

添加新值或者修改值：airports["LHR"] ="London"

removeValue(forKey:)方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回nil

使用for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都以(key, value)元组形式返回:for(airportCode, airportName)inairports {print("\(airportCode):\(airportName)")}

通过访问keys或者values属性，我们也可以遍历字典的键或者值

函数：

func greetAgain(person: String) -> String {return"Hello again, "+ person +"!"} // 指定函数返回类型时，用返回箭头 ->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示

无参数函数，返回值String：func sayHelloWorld()->String {return"hello, world"}

多参数函数，返回值String：func greet(person: String, alreadyGreeted: Bool)->String{}

有参数，无返回值函数：func greet(person: String){print("Hello,\(person)!")}

默认参数值：func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int =12){// 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。}         someFunction(parameterWithoutDefault:4)// parameterWithDefault = 12

枚举：enum CompassPoint {case north case south case east case west}  // 使用case关键字来定义一个新的枚举成员值

多个成员值可以出现在同一行上，用逗号隔开：enum Planet {case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune}

结构体：struct FixedLengthRange{var firstValue : Int   letlength : Int}                                      var  rangeOfThreeItems = FixedLengthRange(firstValue:0, length:3) // 该区间表示整数0，1，2       rangeOfThreeItems.firstValue =6 // 该区间现在表示整数6，7，8

带属性监视器的普通属性 var age:Int = 0 {

        //我们需要在age属性变化前做点什么   willSet { }

        //我们需要在age属性发生变化后，更新一下nickName这个属性  didSet { }   }

类型方法：class SomeClass { class func someTypeMethod() { //在这里实现类型方法} }  SomeClass.someTypeMethod() 

防止重写和继承：只需要在声明关键字前加上final修饰符即可（例如：final var，final func，final class func，以及final subscript），如果重写了带有final标记的方法，属性或下标，在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final 的；以通过在关键字class前添加final修饰符（final class）来将整个类标记为 final 的。这样的类是不可被继承的，试图继承这样的类会导致编译报错。

析构器:  deinit{// 执行析构过程}   析构器是在实例释放发生前被自动调用。你不能主动调用析构器。子类继承了父类的析构器，并且在子类析构器实现的最后，父类的析构器会被自动调用。即使子类没有提供自己的析构器，父类的析构器也同样会被调用。因为直到实例的析构器被调用后，实例才会被释放，所以析构器可以访问实例的所有属性，并且可以根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件）。(- (void)dealloc)

弱引用weak：weak var delegate: GMCitySearchBarDelegate?

无主引用unowned：tagView.tapBlock = { [unowned self](index) in self.tagAction(Int(index))}

可选链：

class Residence {

    var rooms = [Room]()   //数组

    var numberOfRooms: Int {

        return rooms.count

    }

    subscript(i: Int) -> Room {

        get {

            return rooms[i]

        }

        set {

            rooms[i] = newValue

        }

    }

    func printNumberOfRooms() {

        print("The number of rooms is \(numberOfRooms)")

    }

    var address: Address?   //可选项

}

class Room {

    let name: String

    init(name: String) { self.name = name }   

}

用 Do-Catch 处理错误:在catch后面写一个匹配模式来表明这个子句能处理什么样的错误。如果一条catch子句没有指定匹配模式，那么这条子句可以匹配任何错误，并且把错误绑定到一个名字为error的局部常量。

禁用错误传递:有时你知道某个throwing函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写try!来禁用错误传递，这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误，你会得到一个运行时错误。例如，下面的代码使用了loadImage(atPath:)函数，该函数从给定的路径加载图片资源，如果图片无法载入则抛出一个错误。在这种情况下，因为图片是和应用绑定的，运行时不会有错误抛出，所以适合禁用错误传递。let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

指定清理操作:可以使用defer语句在即将离开当前代码块时执行一系列语句。该语句让你能执行一些必要的清理工作，不管是以何种方式离开当前代码块的——无论是由于抛出错误而离开，或是由于诸如return、break的语句。例如，你可以用defer语句来确保文件描述符得以关闭，以及手动分配的内存得以释放。defer语句将代码的执行延迟到当前的作用域退出之前。该语句由defer关键字和要被延迟执行的语句组成。延迟执行的语句不能包含任何控制转移语句，例如break、return语句，或是抛出一个错误。letfile = open(filename) defer { close(file) }

检查类型: if item is Movie {}  (item是Movie类型或者Song类型的)

向下转型:某类型的一个常量或变量可能在幕后实际上属于一个子类。当确定是这种情况时，你可以尝试向下转到它的子类型，用类型转换操作符（as? 或 as!）。因为向下转型可能会失败，类型转型操作符带有两种不同形式。条件形式as? 返回一个你试图向下转成的类型的可选值。强制形式 as! 把试图向下转型和强制解包转换结果结合为一个操作。if let movie = item as? Movie （示例首先试图将 item 下转为 Movie。因为 item 是一个 MediaItem 类型的实例，它可能是一个 Movie；同样，它也可能是一个 Song，或者仅仅是基类 MediaItem。因为不确定，as? 形式在试图下转时将返回一个可选值。item as? Movie 的返回值是 Movie? 或者说“可选 Movie”。）

Any 和 AnyObject 的类型转换：Swift 为不确定类型提供了两种特殊的类型别名：Any 可以表示任何类型，包括函数类型；AnyObject 可以表示任何类类型的实例；

注意：Any类型可以表示所有类型的值，包括可选类型。Swift 会在你用Any类型来表示一个可选值的时候，给你一个警告。如果你确实想使用Any类型来承载可选值，你可以使用as操作符显式转换为Any，如下所示：var things = [Any]()   let optionalNumber: Int? =3    things.append(optionalNumber)// 警告   things.append(optionalNumberasAny)// 没有警告

扩展：使用关键字 extension 来声明扩展：extension SomeType{ // 为 SomeType 添加的新功能写到这里}

可以通过扩展来扩展一个已有类型，使其采纳一个或多个协议。在这种情况下，无论是类还是结构体，协议名字的书写方式完全一样：extension    SomeType:SomeProtocol,AnotherProctocol{ // 协议实现写到这里}

Swift 中的扩展可以：添加计算型属性和计算型类型属性；定义实例方法和类型方法；提供新的构造器；定义下标；定义和使用新的嵌套类型；使一个已有类型符合某个协议

方法：扩展可以为已有类型添加新的实例方法和类型方法。下面的例子为 Int 类型添加了一个名为 repetitions 的实例方法：extension Int {

                func repetitions(task: () -> Void) {     for _ in 0.. { task() }     }}

这个 repetitions(task:) 方法接受一个 () -> Void 类型的单参数，表示没有参数且没有返回值的函数。定义该扩展之后，你就可以对任意整数调用 repetitions(task:) 方法，将闭包中的任务执行整数对应的次数： 3.repetitions({print("Hello!")})   // 输出Hello!// Hello!// Hello!

可以使用尾随闭包让调用更加简洁：3.repetitions {print("Goodbye!")}

可变实例方法：通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改 self 或其属性的方法必须将该实例方法标注为 mutating，正如来自原始实现的可变方法一样。下面的例子为 Swift 的 Int 类型添加了一个名为 square 的可变方法，用于计算原始值的平方值：extension Int{mutating  func  square(){self=self*self}}    var someInt =3   someInt.square()// someInt 的值现在是 9

协议：protocol SomeProtocol{// 这里是协议的定义部分}                                                       struct  SomeStructure:FirstProtocol,AnotherProtocol{// 这里是结构体的定义部分}             class SomeClass:SomeSuperClass,FirstProtocol,AnotherProtocol{// 这里是类的定义部分}协议总是用 var 关键字来声明变量属性，在类型声明后加上 { set get } 来表示属性是可读可写的，可读属性则用 { get } 来表示：                                                                                       protocol SomeProtocol {var mustBeSettable:Int{get set} //可读可写                                         var doesNotNeedToBeSettable: Int{get} //可读}

在协议中定义类型属性时，总是使用 static 关键字作为前缀。当类类型遵循协议时，除了 static 关键字，还可以使用 class 关键字来声明类型属性：protocol  AnotherProtocol{ static var someTypeProperty:Int {getset}}

如下所示，这是一个只含有一个实例属性要求的协议：protocol FullyNamed {var fullName:String {get}}  ：FullyNamed 协议除了要求遵循协议的类型提供 fullName 属性外，并没有其他特别的要求。这个协议表示，任何遵循 FullyNamed 的类型，都必须有一个可读的 String 类型的实例属性 fullName。下面是一个遵循 FullyNamed 协议的简单结构体：        struct Person: FullyNamed {  var fullName: String }

 let john = Person(fullName: "John Appleseed")  // john.fullName 为 "John Appleseed"：这个例子中定义了一个叫做 Person 的结构体，用来表示一个具有名字的人。从第一行代码可以看出，它遵循了 FullyNamed 协议。Person 结构体的每一个实例都有一个 String 类型的存储型属性 fullName。这正好满足了 FullyNamed 协议的要求，也就意味着 Person 结构体正确地符合了协议。（如果协议要求未被完全满足，在编译时会报错。）

下面的例子定义了一个只含有一个实例方法的协议：protocol RandomNumberGenerator{ func random()->Double } ：RandomNumberGenerator 协议要求遵循协议的类型必须拥有一个名为 random， 返回值类型为 Double 的实例方法。RandomNumberGenerator 协议并不关心每一个随机数是怎样生成的，它只要求必须提供一个随机数生成器。class LinearCongruentialGenerator:RandomNumberGenerator{ func random()->Double{ return   lastRandom / m  }}

在Swift中，包含三种类型(type): structure,enumeration,class，其中structure和enumeration是值类型(value type),class是引用类型(reference type)；但是与Objective-C不同的是，structure和enumeration也可以拥有方法(method)，其中方法可以为实例方法(instance method)，也可以为类方法(type method)，实例方法是和类型的一个实例绑定的。虽然结构体和枚举可以定义自己的方法，但是默认情况下，实例方法中是不可以修改值类型的属性。

假如定义一个点结构体，该结构体有一个修改点位置的实例方法：struct Point {  

    var x = 0, y = 0  

    func moveXBy(x:Int,yBy y:Int) {  

        self.x += x  

        // Cannot invoke '+=' with an argument list of type '(Int, Int)'   }  }  

为了能够在实例方法中修改属性值，可以在方法定义前添加关键字mutating

struct Point {  var x = 0, y = 0  

mutating func moveXBy(x:Int,yBy y:Int) { self.x += x  self.y += y   }  }  

var p = Point(x: 5, y: 5)    p.moveXBy(3, yBy: 3) 

枚举: enum OnOffSwitch: Togglable {  case off, on

    mutating func toggle() { switch self { case .off:   self = .on     case .on:  self = .off}}}

var lightSwitch = OnOffSwitch.off    lightSwitch.toggle()    // lightSwitch 现在的值为 .On

构造器要求在类中的实现:你可以在遵循协议的类中实现构造器，无论是作为指定构造器，还是作为便利构造器。无论哪种情况，你都必须为构造器实现标上 required 修饰符。使用 required 修饰符可以确保所有子类也必须提供此构造器实现，从而也能符合协议。class                           SomeClass:SomeProtocol{ required  init(someParameter:Int) {// 这里是构造器的实现部分}}

如果一个子类重写了父类的指定构造器，并且该构造器满足了某个协议的要求，那么该构造器的实现需要同时标注 required 和 override 修饰符：protocol SomeProtocol{init()}

class  SomeSuperClass{init() {// 这里是构造器的实现部分}}

class SomeSubClass:SomeSuperClass,SomeProtocol{// 因为遵循协议，需要加上 required// 因为继承自父类，需要加上 overridere。 quired override init() {// 这里是构造器的实现部分}}