一、常量&變數

在Swift中規定:在定義一個識別符號時必須明確說明該識別符號是一個常量還是變數

1、使用 let 定義常量,定義之後不可以修改

let number = 10
// 常量不可以修改
number = 20 ❌
複製程式碼

2、使用 var 定義變數,定義之後可以修改

var number = 10

number = 20 
複製程式碼

⚠️編譯器會根據給變數或常量所賦的值，推斷它的資料型別。所以這裡系統會認為number是Int型別的

⚠️ swift中輸出語句：print函式

print("Hello Swift")
複製程式碼

二、資料型別

Swift中的資料型別也有:整型/浮點型/字串/物件型別/結構體型別等等

⚠️ Swift是強型別語言

// 定義變數時沒有指定明確的型別,但是因為賦值給i一個20.20為整型.因此i為整型
var i = 20
// 如果之後賦值給i一個浮點型數值,則會報錯
// i = 30.5 ❌
複製程式碼

如果定義一個識別符號時有直接進行賦值,那麼識別符號後面的型別可以省略

如果想要指定常量或變數的資料型別

var number:Float = 10
var name:String = "花花"
複製程式碼

Swift中的基本運算

⚠️ Swift中在進行基本運算時必須保證型別一致,否則會出錯

⚠️ 值不會隱式轉換，需要顯示轉換成其他資料型別

let a = 10
let b = 3.14

// 錯誤寫法
// let
 
 c = a + b ❌
// let c = a * b ❌

// 正確寫法
let c = Double(a) + b
let d = a + Int(b)
複製程式碼

三、字串

字串的使用

1、遍歷字串

// 字串遍歷
var str = "Hello,Swift"
for c in str {
    print(c)
}
複製程式碼

2、字串拼接

let str1 = "Hello"
let str2 = "Swift"
let str3 = str1 + str2
複製程式碼

3、字串插值

let age = 18
let result = "My name is Huahua,age is \(age)"
 

複製程式碼

4、字串的格式化

let str = String(format: "%@=%@",key,value)
複製程式碼

5、使用2對3引號可以表示多行字串

let string = """
Hello Swift!
Hello Swift!
Hello Swift!
"""
複製程式碼

⚠️引號所在行，引號後不能有其他元素

四、陣列

陣列是一串有序的由相同型別元素構成的集合，陣列中的集合元素是有序的，可以重複出現

1、陣列的初始化

⚠️ 宣告陣列

// let代表不可變陣列
let array:Array<String>

// var代表可變陣列
var array: [String]
複製程式碼

⚠️ 初始化陣列

// 定義一個可變陣列,必須初始化才能使用
var array1 : [String] = [String]()

// 定義一個不可變陣列
let array2 : [Any] = ["花花",18]

// 定義時直接初始化
var array = ["a","b","c"]

// 先定義,後初始化
var array : Array<String>
array = ["a","c"]
複製程式碼

2、對陣列的基本操作

// 新增資料
array.append("abc")

// 刪除元素
array.removeFirst()

// 修改元素
array[0] = "asd"

// 取值
array[1]

// 數組合並
// 注意:只有相同型別的陣列才能合併
var array1 = ["a","c"]
var array2 = ["d","e"]
var array3 = array1 + array2
複製程式碼

3、陣列的遍歷

// 遍歷陣列
for i in 0..<array.count {
    print(array[i])
}

// forin方式
for item in array {
    print(item)
}

// 設定遍歷的區間
for item in array[0..<2] {
    print(item)
}
複製程式碼

五、字典

字典是由兩部分集合構成的，一個是鍵（key）集合，一個是值（value）集合。鍵集合是不能有重複元素的，值集合可以重複，鍵和值是成對出現的。

1、字典的初始化

// 定義一個可變字典
var dict1 : [String : Any] = [String : Any]()

// 定義一個不可變字典
let dict2 = ["name" : "花花","age" : 18]
複製程式碼

⚠️ 宣告字典

var dict1: Dictionary<Int,String>
var dict2: [Int: String]
複製程式碼

2、字典的基本操作

// 新增資料
dict["height"] = 1.88

// 刪除欄位
dict.removeValueForKey("height")

// 修改字典
dict["name"] = "花花"

// 查詢字典
dict["name"]

// 字典的合併
var dict1 = ["name" : "花花","age" : 18]
var dict2 = ["height" : 1.8]

// 字典不可以直接相加合併
for (key,value) in dict2 {
    dict1[key] = value
}
複製程式碼

3、字典的遍歷

// 遍歷字典中所有的值
for value in dict.values {
    print(value)
}

// 遍歷字典中所有的鍵
for key in dict.keys {
    print(key)
}

// 遍歷所有的鍵值對
for (key,value) in dict {
    print(key)
    print(value)
}
複製程式碼

六、元祖

元祖是一種資料結構，類似於陣列或字典，用於定義一組資料

1、定義元祖

("1001","花花",18,90)
(id:"1001",name:"張三",age:18,score:90)
複製程式碼

2、元祖的簡單使用

// 元祖:HTTP錯誤
// 寫法一:
let error = (404,"Not Found")
print(error.0)
print(error.1)

// 寫法二:
let error = (errorCode : 404,errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)

// 寫法三:
let (errorCode,errorIno) = (404,"Not Found")
print(errorCode)
print(errorIno)
複製程式碼

七、可選型別（Optional）

在swift開發中,nil也是一個特殊的型別。

1、可選型別的定義

// 寫法一:定義可選型別
let string : Optional<String> = nil

// 寫法二:定義可選型別,語法糖(常用)
let string : String? = nil

// 錯誤寫法
// let string : String = nil ❌
複製程式碼

2、可選型別的使用

// 定義可選型別
var string : String? = nil

// 給可選型別賦值
string = "Hello world"

// 列印結果
print(string)

// 結果:Optional("Hello world")
// 因為打印出來的是可選型別,所有會帶Optional
複製程式碼

3、解包

解包就是取出可選型別的真實值

print(string!) // 結果:Hello world

⚠️注意:如果可選型別為nil,強制取出其中的值(解包),程式會崩潰

string = nil
print(string!) // 報錯 

// 正確寫法:
if string != nil {
    print(string!)
}

// 簡單寫法:為了讓在if語句中可以方便使用string
if var str = string {
    print(str)
}
複製程式碼

4、可選型別使用例項

// 通過該方法建立的URL,可能有值,也可能沒有值

// 正確寫法:使用可選型別來接收
let url : URL? = URL(string: "http://www.baidu.com")

// 錯誤寫法:如果返回值是nil時,就不能接收了
let url : URL = URL(string: "http://www.baidu.com")

// 通過url來建立request物件
if let tempUrl = url {
    let request = NSURLRequest(URL: tempUrl)
}
複製程式碼

八、函式

函式格式:

func 函式名(引數列表) -> 返回值型別 {
    程式碼塊
    return 返回值
}
複製程式碼

• func是關鍵字,多個引數列表之間可以用逗號（,）分隔，也可以沒有引數
• 使用箭頭“->”指向返回值型別
• 如果函式沒有返回值，返回值為Void.“-> 返回值型別”部分可以省略

1、常見函式型別

<1 沒有引數,沒有返回值

func test() -> Void {
    print("Hello Swift")
}

// 呼叫函式
test()

// 簡單寫法
// 如果沒有返回值,後面的內容可以都不寫
func test2() {
   print("Hello Swift")
}
複製程式碼

<2 有引數,沒返回值

func test(name : String) {
    print("Hello\(name)")
}
test(name: "Swift")
複製程式碼

<3 沒引數,有返回值

func getSth() -> String {
    return "花花"
}
var str = getSth()
print(str)
複製程式碼

<4 有引數,有返回值

func sum(num1 : Int,num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20,num2: 30)
print(result)
複製程式碼

2、外部引數&內部引數

在函式外面可以看到的引數,就是外部引數。在函式內部可以看到的引數,就是內部引數。

⚠️ 如果不想要外部引數,可以在引數名稱前加_

// number1、number2和number3是外部引數的名稱

func mutiple(number1 num1 : Int,number2 num2 : Int,number3 num3 : Int) -> Int {
    return num1 * num2 * num3
}
var result1 = mutiple(number1: 20,number2: 4,number3: 5)
複製程式碼

3、預設引數

某些情況,如果沒有傳入具體的引數,可以使用預設引數

func makecoffee(type :String = "卡布奇諾") -> String {
    return "製作一杯\(type)咖啡。"
}

let coffee1 = makecoffee("拿鐵")
let coffee2 = makecoffee()
複製程式碼

4、可變引數

swift中函式的引數個數可以變化，它可以接受不確定數量的輸入型別引數（必須具有相同的型別），我們可以通過在引數型別名後面加入（...）的方式來指示這是可變引數

func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(100.0,20,50)
複製程式碼

5、引用型別

預設情況下,函式的引數是值傳遞.如果想改變外面的變數,則需要傳遞變數的地址

inout關鍵字

func swap(a : inout Int,b : inout Int) {
   let temp = a
   a = b
   b = temp
}

var a = 10
var b = 20
swap(a: &a,b: &b)
print("a:\(a),b:\(b)")
複製程式碼

6、方法過載

方法過載:方法名稱相同,但是引數不同

func mutiple(_ num1: Int,_ num2 :Int) -> Int {
    return num1 * num2
}

var result2 = mutiple(20,20)
複製程式碼

九、 閉包

閉包是一個特殊函式

1、定義閉包

型別:(形參列表)->(返回值)

技巧:定義閉包型別時,直接寫()->().再填充引數和返回值

{
    (形參) -> 返回值型別 in
    // 執行程式碼
}
複製程式碼

2、閉包的使用

// 定義網路請求類
class HttpTool: NSObject {
    func loadRequest(callBack: ()->()){
        print("載入資料..")
        callBack()
    }
}

// 網路請求
let httpTool = HttpTool()
httpTool.loadRequest ({ () -> () in
    print("載入完成")
})   
複製程式碼

3、閉包的簡寫

• 如果閉包沒有引數,沒有返回值.in和in之前的內容可以省略

httpTool.loadRequest({
    print("載入完成")
})
複製程式碼

⚠️ 尾隨閉包

• 尾隨閉包寫法
  • 如果閉包是函式的最後一個引數,則可以將閉包寫在()後面
  • 如果函式只有一個引數,並且這個引數是閉包,那麼()可以不寫

httpTool.loadRequest() {
    print("載入完成")
}
複製程式碼

// 開發中建議該寫法
httpTool.loadRequest {
    print("載入完成")
}
複製程式碼

4、閉包的迴圈使用

• 如果在HttpTool中有對閉包進行強引用,則會形成迴圈引用

class HttpTool: NSObject {
    // 定義屬性,強引用傳入的閉包
    var callBack : (()->())?

    func loadRequest(callBack : ()->()){
        callBack()
        self.callBack = callBack
    }
}
複製程式碼

• swift中解決迴圈引用的方式

// [weak self] () -> () in
httpTool.loadRequest { [weak self] in
    self.view.backgroundColor = UIColor.redColor()
}
複製程式碼

十、 懶載入

定義：用到時候才載入

懶載入的本質是,在第一次使用的時候執行閉包,將閉包的返回值賦值給屬性

• lazy的作用是隻會賦值一次

lazy var array : [String] = {
    () -> [String] in
    return ["a","c"]
}()
複製程式碼

十一、類

Swift是一門面向物件開發的語言，面向物件的基礎是類

1、類的定義

class 類名 : SuperClass {
    // 定義屬性和方法
}
複製程式碼

⚠️ 定義的類,可以沒有父類.那麼該類是 rootClass

2、類的屬性

• Swift中類的屬性有多種
  • 儲存屬性:儲存例項的常量和變數
  • 計算屬性:通過某種方式計算出來的屬性
  • 類屬性:與整個類自身相關的屬性

儲存屬性

• 儲存屬性是最簡單的屬性，它作為類例項的一部分，用於儲存常量和變數
• 可以給儲存屬性提供一個預設值，也可以在初始化方法中對其進行初始化

class Student : NSObject {
    // 儲存屬性
    var age : Int = 0
    var name : String?
    var englishScore : Double = 0.0
    var mathScore : Double = 0.0
}

// 建立學生物件
let stu = Student()
// 給儲存屬性賦值
stu.age = 10
stu.name = "花花"
stu.englishScore = 80.0
stu.mathScore = 90.0
複製程式碼

計算屬性

• 計算屬性並不儲存實際的值，而是提供一個getter和一個可選的setter來間接獲取和設定其它屬性
• 儲存屬性一般只提供getter方法
• 如果只提供getter，而不提供setter，則該計算屬性為只讀屬性,並且可以省略get{}

class Student : NSObject {
    // 儲存屬性
    var age : Int = 0
    var name : String?
    var englishScore : Double = 0.0
    var mathScore : Double = 0.0
    
    // 計算屬性
    var averageScore : Double {
        get {
            return (englishScore + mathScore) / 2
        }
        // newValue是系統分配的變數名,內部儲存著新值
        set {
            self.averageScore = newValue
        }
    }
}
複製程式碼

類屬性

• 類屬性是與類相關聯的，而不是與類的例項相關聯
• 類屬性使用static來修飾

class Student : NSObject {
    // 儲存屬性
    var age : Int = 0
    var name : String?

    var englishScore : Double = 0.0
    var mathScore : Double = 0.0

    // 計算屬性
    var averageScore : Double {
        get {
            return (englishScore + mathScore) / 2
        }

        // 沒有意義.newValue是系統分配的變數名,內部儲存著新值
        set {
            self.averageScore = newValue
        }
    }

    // 類屬性
    static var corseCount : Int = 0
}

// 設定類屬性的值
Student.corseCount = 3
複製程式碼

3、監聽屬性的改變

Swift中可以通過屬性觀察者來監聽和響應屬性值的變化

• 通常是監聽儲存屬性和類屬性的改變.(對於計算屬性，我們不需要定義屬性觀察者，因為我們可以在計算屬性的setter中直接觀察並響應這種值的變化)

• 我們通過設定以下觀察方法來定義觀察者

  • willSet：在屬性值被儲存之前設定。此時新屬性值作為一個常量引數被傳入。該引數名預設為newValue，我們可以自己定義該引數名
  • didSet：在新屬性值被儲存後立即呼叫。與willSet相同，此時傳入的是屬性的舊值，預設引數名為oldValue

class Person : NSObject {
    var name : String? {
        // 可以給newValue自定義名稱
        willSet (){ 
            // 屬性即將改變,還未改變時會呼叫的方法
            // 在該方法中有一個預設的系統屬性newValue,用於儲存新值
            print(newValue)
        }
        didSet (oldValue) {
            // 屬性值已經改變了,會呼叫的方法
            // 在該方法中有一個預設的系統屬性oldValue,用於儲存舊值
            print(oldValue)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在賦值時,監聽該屬性的改變
// 在OC中是通過重寫set方法
// 在swift中,可以給屬性新增監聽器
p.name = "花花"
複製程式碼

十二、類的建構函式

• 建立一個類時,必然會呼叫一個建構函式
• 即便是沒有編寫任何建構函式，編譯器也會提供一個預設的建構函式。
• 如果是繼承自NSObject,可以對父類的建構函式進行重寫

1、建構函式的基本使用

class Person: NSObject {
    var name : String = ""
    var age : Int = 0

    // 重寫了NSObject(父類)的構造方法
    override init() {
        name = ""
        age = 0
    }
}

// 建立一個Person物件
let p = Person()
複製程式碼

2、初始化時給屬性賦值

很多時候,我們在建立一個物件時就會給屬性賦值，可以自定義建構函式 ⚠️ 如果自定義了建構函式,會覆蓋init()方法.即不在有預設的建構函式

class Person: NSObject {
    var name : String?
    var age : Int = 0

    // 自定義建構函式,會覆蓋init()函式
    init(name : String,age : Int) {
        self.name = name
        self.age = age
    }
}

// 建立一個Person物件
let p = Person(name: "花花",age: 18)
複製程式碼

十三、Swift邏輯分支

通過分支語句可以控制程式的執行流程

• 在Swift的判斷句中必須有明確的真假 false/true

1、if語句

let a = 10

// 錯誤寫法:❌
//if a {
//    print("a")
//}

// 正確寫法
if a > 9 {
    print(a)
}
複製程式碼

這個是可選型別,因為只有宣告成可選型別後,才可以判斷是否為空

let view : UIView? = UIView()

// 判斷如果view有值,則設定背景顏色
// 錯誤寫法 ❌
//if view {
//    view.backgroundColor = UIColor.redColor()
//}

if view != nil {
    view!.backgroundColor = UIColor.redColor()
}
複製程式碼

2、if/else if/else 語句

let score = 87

if score < 60 {
    print("不及格")
} else if score <= 70 {
    print("及格")
} else if score <= 80 {
    print("良好")
} else if score <= 90 {
    print("優秀")
} else {
    print("完美")
}
複製程式碼

3、三目運算子

var a = 10
var b = 50

var result = a > b ? a : b
print(result)
複製程式碼

4、guard語句

guard是Swift2.0新增的語法，它設計的目的是提高程式的可讀性

• guard語法：
  • 當條件表示式為true時候跳過else語句中的內容，執行後面的程式碼
  • 條件表示式為false時候執行else語句中的內容，跳轉語句一般是return、break、continue和throw

guard 條件表示式 else {
    // do sth..
    return
}
do sth...
複製程式碼

使用例項：

var age = 18

func online(age : Int) -> Void {
    guard age >= 18 else {
        print("回家去")
        return
    }

    print("可以上網")
}

online(age)
複製程式碼

5、switch分支

switch後可以不跟()，case後可以不跟break(預設會有break)

let sex = 0

switch sex {
case 0 :
    print("男")
case 1 :
    print("女")
default :
    print("其他")
}
複製程式碼

如果希望出現之前的case穿透,則可以使用關鍵字fallthrough

let sex = 0

switch sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}
複製程式碼

swift支援多種資料型別

• 浮點型的switch判斷

let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}
複製程式碼

• 字串型別

let opration = "+"

switch opration {
    case "+":
        print("+")
    case "-":
        print("-")
    case "*":
        print("*")
    case "/":
        print("/")
default:
    break
}
複製程式碼

• switch支援區間判斷

let score = 88

switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("及格")
case 80..<90:
    print("良好")
case 90..<100:
    print("優秀")
default:
    print("滿分")
}
複製程式碼

十四、迴圈

1、for迴圈

for i in 0..<10 {
    print(i)
}

for i in 0...10 {
    print(i)
}
複製程式碼

2、while迴圈

var a = 0
while a < 10 {
    a++
}
複製程式碼

3、repeat while 迴圈

let b = 0
repeat {
    print(b)
    b++
} while b < 20
複製程式碼