空合并運(yùn)算符

var count:Int? = 10
var value:Int

/// 空合并運(yùn)算符   第一個(gè)操作數(shù)必須為optional 如果不為nil責(zé)將進(jìn)行拆包操作
print(count ?? 0)  和 三目運(yùn)算符 print(count != nil ? count! : 0) 結(jié)果一樣

結(jié)果為：10

元祖

/// 定義元祖
var student:(String,Int,Float) = ("kakaxi",20,185.0)
/// var stu:(name:String,age:Int,height:Float) = ("kakaxi",20,185.0)

print(student.0)
/// 將元祖進(jìn)行分解   分解命名時(shí)使用_忽略命名字段
var (name,_,_) = student

print(name)

結(jié)果為：kakaxi

數(shù)組

聲明一個(gè)十個(gè)元素相同的數(shù)組
var array = [String](repeating: "helllo world", count: 10)
var arrList = [0,1,2,3,4]

遍歷數(shù)組的不同方式
for item in arrList {
    print(item)
}
0
1
2
3
4

for item in arrList.enumerated() {
    print(item)
}
(offset: 0, element: 0)
(offset: 1, element: 1)
(offset: 2, element: 2)
(offset: 3, element: 3)
(offset: 4, element: 4)

for index in arrList.indices {
    print(arrList[index], separator:"")
}

0
1
2
3
4

字典

var dicts:Dictionary<Int,String>
dicts = [1:"1",2:"2"]
print(dicts)

結(jié)果為：[2: "2", 1: "1"]

Set

集合(Set)

集合(Set)特點(diǎn)：無序、唯一性、集合操作、快速查找。
集合的數(shù)據(jù)顯示和數(shù)組是一樣的，所以必須顯示的聲明Set集合！不然！就是數(shù)組！
// 初始化A、B、C三個(gè)集合
var A:Set<String> = ["A", "B", "C", "D"]
var B:Set<String> = ["C", "D", "E", "F"]
var C:Set<String> = ["B", "B", "C"]

// 上面Array、Dictionary動(dòng)態(tài)初始化有四種，這里面只有兩種
var set1 = Set<String>()
var set2:Set<String> = []

// 集合的數(shù)量
A.count
// 集合第一個(gè)元素，因?yàn)榧系臒o序性，它的第一個(gè)元素沒有意義
A.first
// 集合是否為空
A.isEmpty
// 向集合中插入一個(gè)元素
A.insert("C")
// 刪除集合中的元素
A.remove("C")
// 判斷集合中是否包含某個(gè)元素
A.contains("A")
// 遍歷集合
for index in A {
    index
}

運(yùn)算符

///通過~=運(yùn)算符來檢查某個(gè)數(shù)字是否包含在范圍中
var range = 0...10
print(range~=8)   true

while和repeat-while 條件循環(huán)結(jié)構(gòu)

當(dāng) i 大于等于10的時(shí)候跳出循環(huán)   
var i = 0
while i < 10 {
    print("while",i)
    i += 1
}

repeat while 循環(huán)

先執(zhí)行循環(huán)體，在進(jìn)行條件判斷  和 OC 中的 do - while功能基本一致
var j = 0
repeat{
    print("while",j)
    j+=1
}while j < 10

流程跳轉(zhuǎn)語句

swift中提供的流程跳轉(zhuǎn)語句主要有：continue、break、fallthrough、return、throw、guard

continue: 語句用于循環(huán)結(jié)構(gòu)中，作用為跳過本次循環(huán)，直接開始下次循環(huán)
break：中斷語句，也可以用于循環(huán)結(jié)構(gòu)中，和continue語句不同，break語句會(huì)直接中斷包含它的循環(huán)結(jié)構(gòu)
fallthrough：語句是swift中特有的一種流程控制語句，可以再中斷語句中繼續(xù)執(zhí)行下面的語句

例如：
var i = 3
switch i {
case 1...3:
print("switch")
    fallthrough
default:
    print("default")
}
結(jié)果為：switch   default
如果不加fallthrough 結(jié)果為：switch

return: 用于返回結(jié)果值，或者用于提前結(jié)束無返回值類型的函數(shù)

throw: 語句用于拋出異常，拋出的異常如果不進(jìn)行捕捉處理，也會(huì)使程序中斷

guard - else: 是Swift2.0之后新加入的一種語法結(jié)構(gòu)，Swift團(tuán)隊(duì)創(chuàng)造它的目的在于是代碼結(jié)構(gòu)和邏輯更加清晰

func normalFunc(param:Int){
    if param <= 0 {
        return
    }
    print(param)
}

func fuardFunc(param:Int){
    guard param > 0 else {
        return
    }
    print(param)
}

聲明函數(shù)

有參數(shù)有返回值
func compare(param1:Int,param2:Int)->Int {
    return param1 + param2
}

var add = compare(param1: 10, param2: 20)
print(add)   30

func search(searchID:Int)->(success:Bool,data:String){
    let reust = true
    let data = "數(shù)據(jù)實(shí)體"
    return(reust,data)
}

if search(searchID: 1000).success {
    print(search(searchID: 1000).data)   數(shù)據(jù)實(shí)體
}

函數(shù)的參數(shù)可以傳也可以不傳(設(shè)置默認(rèn)值)
func myFunc(param1:Int,param2:Int = 10)->Int {
    return param1 + param2
}

print(myFunc(param1: 8))   18
print(myFunc(param1: 10, param2: 40))    50

函數(shù)可以多參數(shù)，也可以多個(gè)不確定參數(shù)
在參數(shù)后面添加...   
func funcParams(param:Int...)->Int{
    var sum = 0
    for count in param {
        sum+=count
    }
    return sum
}
print(funcParams(param: 10,20,30,40,50))   150

聲明一個(gè)函數(shù)變量
var addFunc:(Int...)->Int
addFunc = funcParams
print(addFunc(100,200))   300

函數(shù)重載    相同方法名   參數(shù)返回值不同
func addFunc(param1:Int,param2:Int)->Int{
    return param1 + param2
}
func addFunc(param1:Double,param2:Double)->Double{
    return param1 + param2
}
func addFunc(param1:String,param2:String)->String{
    return param1 + param2
}

閉包

閉包標(biāo)準(zhǔn)結(jié)構(gòu)：
{（參數(shù)列表）-> 返回值 in 閉包體}
首先閉包最外層由大括號(hào)包圍，內(nèi)部由閉包關(guān)鍵字in來進(jìn)行分割，關(guān)鍵字in前面為閉包結(jié)構(gòu)的參數(shù)列表和返回值，其書寫規(guī)則與函數(shù)一致，in關(guān)鍵字后面為閉包體，用于實(shí)現(xiàn)具體功能

let closures = {(param:Int)->Int in
    return param * param
}

自定義運(yùn)算符

prefix operator ++
prefix func ++(param:Int)->Int
{
    return param + 1
}

枚舉

enum Season {
    case spring
    case summer
    case autumn
    case winter
}
let season = Season.spring

func switchFunc(){
    switch season {
    case .spring:
        print("spring")
    case .summer:
        print("summer")
    case .autumn:
        print("autumn")
    default:
        print("winter")
    }
}

switchFunc()   spring

結(jié)構(gòu)體

swift 既可以聲明屬性也可以定義方法

struct Car {
    var price:Int
    var brand:String
    var petrol:Int
    mutating func Drive(){
        if petrol > 0 {
            print("driving")
        }else{
            print("drived")
        }
    }
}

var car = Car(price: 100000, brand: "寶馬", petrol: 10)
car.Drive()   //  driving

類

在創(chuàng)建類時(shí)，使用final關(guān)鍵字  其類不可以被繼承  
使用final聲明屬性時(shí)，其屬性不可以被子類使用

指定構(gòu)造方法與遍歷構(gòu)造方法

對(duì)于類來說，構(gòu)造方法有指定構(gòu)造方法和便利構(gòu)造方法之分。 指定構(gòu)造方法的官方名稱為Designated,遍歷構(gòu)造方法為Convenience。
 指定構(gòu)造方法不需要任何關(guān)鍵字修飾，便利構(gòu)造方法需要使用Convenience關(guān)鍵字來修飾。
關(guān)于指定構(gòu)造方法和便利構(gòu)造方法，Swift語言中有這樣的規(guī)定：
1.  子類的指定構(gòu)造方法中必須調(diào)用父類的指定構(gòu)造方法。
2.  遍歷構(gòu)造方法中必須調(diào)用當(dāng)前類的其他構(gòu)造方法。
3.  遍歷構(gòu)造方法歸根結(jié)底要調(diào)用到某個(gè)指定構(gòu)造方法。

// 創(chuàng)建一個(gè)類作為基類
class BaseClass {
    // 提供一個(gè)指定構(gòu)造方法
    init() {
        print("baseClass Designted")
    }
    
    // 提供一個(gè)便利構(gòu)造方法
    // 便利構(gòu)造方法必須調(diào)用當(dāng)前類中的其他構(gòu)造方法，并最終調(diào)用到指定構(gòu)造方法
    convenience init(param:String) {
        print("BaseClass Convenience")
        /// 進(jìn)行指定構(gòu)造方法的調(diào)用
        self.init()
    }
    
}

/// 創(chuàng)建一個(gè)BaseClass的子類
class SubClass: BaseClass {
    // 覆寫指定構(gòu)造方法中必須調(diào)用父類的指定構(gòu)造方法
    override init() {
        super.init()
    }
    
    // 提供兩個(gè)便利構(gòu)造方法
    convenience init(param:String) {
        // 最終調(diào)用到某個(gè)指定構(gòu)造方法
        self.init()
    }
    
    convenience init(param:Int) {
        // 調(diào)用一個(gè)便利構(gòu)造方法
        self.init(param: "Swift")
        
    }
}

var obj = SubClass()
print(obj)     // baseClass Designted   conditation.SubClass

引用計(jì)數(shù)

Swift中語言中的數(shù)據(jù)傳遞分為兩種，即值類型的數(shù)據(jù)傳遞和引用類型的數(shù)據(jù)傳遞

對(duì)于值類型的數(shù)據(jù)傳遞，其采用的是完全復(fù)制的原理，因此原數(shù)據(jù)的銷毀與內(nèi)存的釋放并不會(huì)影響新數(shù)據(jù)，
新數(shù)據(jù)占用的內(nèi)存會(huì)在它本身作用域結(jié)束時(shí)釋放。

if true {
    var a = 0
    if true {
        var b = 1
        a = b
    }
    // 此時(shí)變量b所占內(nèi)存被釋放
}
// 此處變量a所占內(nèi)存被釋放

引用數(shù)據(jù)類型的數(shù)據(jù)傳遞就復(fù)雜一些，我們知道引用類型的數(shù)據(jù)傳遞并不會(huì)完全復(fù)制原數(shù)據(jù)，
而是通過要引用的方式對(duì)原數(shù)據(jù)進(jìn)行訪問，因此無論一個(gè)類實(shí)例被多少個(gè)變量所承載，其真正所訪問的內(nèi)存都是同一個(gè)地方。
if true {
    var a = TestClass()
    if true {
        var b = a
    }
    // 此處變量b已經(jīng)不存在，但是TestClass實(shí)例依然占用內(nèi)存, 沒有釋放
}
// 此處變量a已經(jīng)不存在，也沒有其他變量引用TestClass實(shí)例，該實(shí)例將調(diào)用deinit方法，其所占內(nèi)存被釋放

循環(huán)引用及其解決方法

循環(huán)引用一直是初級(jí)開發(fā)者編程的噩夢(mèng)。對(duì)類實(shí)例進(jìn)行不當(dāng)?shù)囊脮?huì)造成內(nèi)存泄露，內(nèi)存泄露積累到一定程度就會(huì)給應(yīng)用程序帶來災(zāi)難性的后果。

class ClassOne{
    deinit {
        print("ClassOne deinit")
    }
}

class ClassTwo{
    /// ClassTwo 類中有一個(gè)ClassOne類的屬性
    var classOne:ClassOne?
    init(classOne:ClassOne?) {
        self.classOne = classOne
    }
    deinit {  /// 析構(gòu)方法  相當(dāng)于OC中的dealloc
        print("ClassTwo deinit")
    }
}

var classOne:ClassOne? = ClassOne()
var classTwo:ClassTwo? = ClassTwo(classOne: classOne)
/// 此時(shí)ClassTwo類中的classOne屬性依然在引用classOne實(shí)例，因此classOne實(shí)例所占內(nèi)存沒有釋放
classOne = nil
/// 此時(shí)classTwo 被釋放，classTwo中的屬性也都被釋放，不在有誰引用classOne，classOne實(shí)例也被釋放
classTwo = nil

結(jié)果為：
   ClassTwo deinit
   ClassOne deinit   

**上述代碼十分健康，兩個(gè)類都被釋放**


class ClassOne{
    var cls:ClassTwo?
    deinit {
        print("ClassOne deinit")
    }
}

class ClassTwo{
    /// ClassTwo 類中有一個(gè)ClassOne類的屬性
    var cls:ClassOne?
    init(cls:ClassOne?) {
        self.cls = cls
    }
    deinit {
        print("ClassTwo deinit")
    }
}

var classOne:ClassOne? = ClassOne()
var classTwo:ClassTwo? = ClassTwo(cls: classOne)
classOne?.cls = classTwo

classTwo = nil
classOne = nil

**上述兩個(gè)類都沒有被釋放，代碼中已將將classOne和classTwo都置為nil，但其所占據(jù)的內(nèi)存將無法釋放，這便是循環(huán)引用最常見的場(chǎng)景**

Swift 語言中提供了弱引用關(guān)鍵字（weak）來處理這樣的問題；weak 關(guān)鍵字的作用是在使用這個(gè)實(shí)例的時(shí)候并不保有次實(shí)例的引用
（普通的引用類型數(shù)據(jù)在傳遞時(shí)會(huì)使實(shí)例的引用計(jì)數(shù)加1，使用weak關(guān)鍵字修飾的引用類型數(shù)據(jù)在傳遞時(shí)不會(huì)使引用計(jì)數(shù)加1）

將ClassOne中的屬性 使用weak 聲明：
  weak var cls:ClassTwo?
結(jié)果為：
     ClassTwo deinit
     ClassOne deinit   

擴(kuò)展：
**
弱引用還有一個(gè)特點(diǎn)，其職能修飾Optional類型的屬性，被弱引用的實(shí)例釋放后，這個(gè)屬性會(huì)被自動(dòng)設(shè)置為nil，那么問題來了，如果開發(fā)中使用到的屬性是非Optional值類型的，又恰巧出現(xiàn)了循環(huán)引用的場(chǎng)景，開發(fā)者該如何處理呢？其實(shí)Swift語言中還提供了一個(gè)關(guān)鍵字(unowned 無主引用)來處理非Optional值類型屬性的循環(huán)引用問題。
**