導(dǎo)入格式

import UIKit // 在OC 中的導(dǎo)入格式是：#import<UIkit/UIKit.h>,swift相比于OC更加簡潔

基礎(chǔ)部分

一晤郑、常量和變量

在swift中使用var表示變量，let表示常量

“Swift 包含了 C 和 Objective-C 上所有基礎(chǔ)數(shù)據(jù)類型恍涂，Int表示“整型值； Double 和 Float 表示浮點型值； Bool 是布爾型值康震；String 是文本型數(shù)據(jù)。 Swift 還提供了三個基本的集合類型宾濒，Array 腿短，Set 和 Dictionary ，詳見集合類型”

#常量

// 指定常量的類型
let isSuccess:Bool = true
let aString :String = "i`m a string ??"
let aInt :Int = 666
// 不指定常量類型，編譯器自動去判斷
let ?? = "i`m a dog"
let bInt = 888
** 常量的值不可以去修改 **

運行結(jié)果

Paste_Image.png

Paste_Image.png

#變量

// 變量
//指定變量類型
var bString :String
bString = aString
var cInt:Int
cInt = bInt

// 不指定類型
var dInt = bInt

//修改值
dInt = 0000
bString = "it`s can change"

運行結(jié)果

Paste_Image.png

二橘忱、數(shù)值類型轉(zhuǎn)換

// 整數(shù)和浮點型轉(zhuǎn)換
let three = 3  // 3
let doubleNumber = 0.1415926   // 0.1415926
let pi = Double(three)+doubleNumber  // 3.1415926
// 浮點數(shù)到整數(shù)的反轉(zhuǎn)換
let intPi = Int(pi) // 3

三赴魁、類型別名

“類型別名（type aliases）就是給現(xiàn)有類型定義另一個名字。你可以使用typealias關(guān)鍵字來定義類型別名钝诚∮庇”

typealias MyStr = String
let Str:MyStr = "我是字符串"   //  "我是字符串"

四、元組

“元組（tuples）把多個值組合成一個復(fù)合值凝颇。元組內(nèi)的值可以是任意類型潘拱，并不要求是相同類型∨÷裕”
下面這個例子中芦岂，(404, "Not Found") 是一個描述 HTTP 狀態(tài)碼（HTTP status code）的元組。HTTP 狀態(tài)碼是當你請求網(wǎng)頁的時候 web 服務(wù)器返回的一個特殊值垫蛆。如果你請求的網(wǎng)頁不存在就會返回一個 404 Not Found 狀態(tài)碼禽最。

let http404Error = (404, "Not Found")
// http404Error 的類型是 (Int, String)，值是 (404, "Not Found")”

**#元組的取值方式 **
元組的取值方式主要有三種：
1.通過內(nèi)容分解
2.通過下標
3.通過元素別名

// 1.通過內(nèi)容分解來取值
let (errorCode,message) = http404Error
print("errorCode is \(errorCode)")     // "errorCode is 404"
print("message is \(message)")        // "message is Not Found"
// 如果只需要一個值得話,可以把要忽略的部分用下劃線_標記
let (errorCode1,_) = http404Error   // "404"
print(errorCode1)

// 2.通過下標來取值
let httpCode = http404Error.0  // 404

//3.通過元素的別名來取值
//先給元素起個別名
let http404ErrorName = (errorCode:404,message:"Not Found")
let errorMessage = http404ErrorName.message  // "Not Found"

五月褥、可選類型(optionals)

*** 在OC中我們定義一個暫時不用的變量的時候可以這樣：Int a ,NSString str = nil.但是在swift中不允許這樣弛随，因為swift是強類型語言，nil在swift中也是一種類型宁赤，類型不一樣是不可以賦值的舀透，所以推出了一種可選類型，在swift中規(guī)定：在創(chuàng)建對象時决左，對象中的任何屬性都必須要有一個明確的初始化值** *

Swift 的 Int 類型有一種構(gòu)造器愕够，作用是將一個 String 值轉(zhuǎn)換成一個 Int 值。然而佛猛，并不是所有的字符串都可以轉(zhuǎn)換成一個整數(shù)惑芭。字符串 "123" 可以被轉(zhuǎn)換成數(shù)字 123 ，但是字符串 "hello, world" 不行继找。

“l(fā)et possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推測為類型 "Int?"遂跟， 或者類型 "optional Int”

因為該構(gòu)造器可能會失敗，所以它返回一個可選類型（optional）Int婴渡，而不是一個 Int幻锁。一個可選的 Int 被寫作 Int? 而不是 Int。問號暗示包含的值是可選類型边臼，也就是說可能包含 Int 值也可能不包含值哄尔。（不能包含其他任何值比如 Bool 值或者 String 值。只能是 Int 或者什么都沒有柠并。）

// 你可以給可選變量賦值為nil來表示它沒有值：
serverResponseCode = nil
// serverResponseCode 現(xiàn)在不包含值”

** # if語句和強制解析 **
你可以使用 if 語句和 nil 比較來判斷一個可選值是否包含值岭接。你可以使用“相等”(==)或“不等”(!=)來執(zhí)行比較富拗。

如果可選類型有值，它將不等于 nil：

if convertedNumber != nil {
    print("convertedNumber contains some integer value.")
}
// 輸出 "convertedNumber contains some integer value.

確定可選類型確實包含值之后鸣戴，你可以在可選的名字后面加一個感嘆號（!）來獲取值啃沪。這個驚嘆號表示“我知道這個可選有值，請使用它葵擎×掳ⅲ”這被稱為可選值的強制解析

if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
}
// 輸出 "convertedNumber has an integer value of 123.

# 可選綁定
*** 使用可選綁定（optional binding）來判斷可選類型是否包含值，如果包含就把值賦給一個臨時常量或者變量酬滤∏┎停可選綁定可以用在 if 和 while 語句中，這條語句不僅可以用來判斷可選類型中是否有值盯串，同時可以將可選類型中的值賦給一個常量或者變量 ** *

if let actualNumber = Int(possibleNumber) {
    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
} else {
    print("\'\(possibleNumber)\' could not be converted to an integer")
}
// 輸出 "'123' has an integer value of 123

這里面其實進行了兩步操作：1.先判斷possibleNumber 是不是nil氯檐，是的話就不執(zhí)行大括號里的語句。2.不空的話對possibleNumber 進行解包賦值 .但是這種的話每次都得起一個別名

** # ??(空合運算符)**
**空合運算符（a ?? b）將對可選類型 a 進行空判斷体捏，如果 a 包含一個值就進行解封冠摄，否則就返回一個默認值 b。表達式 a 必須是 Optional 類型几缭。默認值 b 的類型必須要和 a 存儲值的類型保持一致河泳。 **

let nickName :String? = nil
let fullName :String = "Harry"
// 如果可選值nickName是nil的話可以使用默認值來代替.??用來提供一個默認值
let inforGrreting = (nickName ?? fullName)

字符串和字符(字符串是值類型)

1.初始化
初始化有兩種方式

//1.使用初始化方法初始化
var anotherEmptyString = String()   
//2. 使用字符串常量初始化 
var str = "Hello, playground"
var str0 = ""   //初始化一個空字符串  

可以通過檢查其Bool類型的isEmpty屬性來判斷該字符串是否為空：

if emptyString.isEmpty {
    print("Nothing to see here")
}
// 打印輸出："Nothing to see here

2.字符串的操作（增刪改）

// 1.字符串拼接
var s = "我是原始的"   // "我是原始的"
let s0 = s + "\n 我是通過+追加的字符串" // "我是原始的\n 我是通過+追加的字符串"
s += s0  //通過賦值運算符(+=)將一個字符串添加到一個已經(jīng)存在字符串變量上
s.append("\n 我是append拼接的字符串")  // "我是原始的我是原始的\n 我是通過+追加的字符串\n 我是append拼接的字符串"
// 2. 計算字符數(shù)量
// 如果想要獲得一個字符串中 Character 值的數(shù)量，可以使用字符串的 characters 屬性的 count 屬性

// 3. 訪問和修改字符串
// 關(guān)鍵字 string.Index ,對應(yīng)著字符串中的每一個character 的位置
// 使用 startIndex 屬性可以獲取一個 String 的第一個 Character 的索引年栓。使用 endIndex 屬性可以獲取最后一個 C haracter 的后一個位置的索引拆挥。因此， endIndex 屬性不能作為一個字符串的有效下標某抓。如果 String 是空串纸兔， artIndex 和 endIndex 是相等的
let sss = "hello world"    // "hello world"
// .endIndex.predecessor ,獲取最后一個字符，swift3中用的是index(befor:)
sss[sss.startIndex]  // "h"
sss[sss.index(after: sss.startIndex)]   //  "e"
sss[sss.index(before: sss.endIndex)]  // "d"
// 通過下標語法獲取
let index = sss.index(sss.startIndex, offsetBy: 7)   // 7
let indexStr = sss[index]  // "o"

// 截取字符串
var  strNum = "12>345</6"
//let startIndex = strNum.range(of: ">")?.lowerBound
//let startIndex0 = strNum.characters.index(of: ">")
//let endIndex0 = strNum.characters.index(of: "<")
//// “endIndex屬性可以獲取最后一個Character的后一個位置的索引”,這里是upperBound
//let end = strNum.range(of: "</")?.upperBound
//let endIndex = strNum.index(before: end!)
//
//let range = Range(uncheckedBounds: (startIndex0!,endIndex))
//let newS = strNum.substring(with: range)

let startIndex = strNum.range(of: ">")?.upperBound
let endIndex = strNum.range(of: "</")?.lowerBound
let range = Range(uncheckedBounds: (startIndex!,endIndex!))
let newS = strNum.substring(with: range)


// 插入和刪除
// 調(diào)用 insert(_:atIndex:) 方法可以在一個字符串的指定索引插入一個字符否副，調(diào)用 insert(contentsOf:at:) 方法可以在一個字符串的指定索引插入一個段字符串
var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)
// welcome 變量現(xiàn)在等于 "hello!"
 
// 調(diào)用 remove(at:) 方法可以在一個字符串的指定索引刪除一個字符汉矿，調(diào)用 removeSubrange(_:) 方法可以在一個字符串的指定索引刪除一個子字符串。

“welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome 現(xiàn)在等于 "hello there"
 
let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// welcome 現(xiàn)在等于 "hello”

welcome.insert(contentsOf:" there".characters, at: welcome.index(before: welcome.endIndex))
// welcome 變量現(xiàn)在等于 "hello there!

// 4 . 遍歷字符串
for character in label.characters
{
    print(character)
}

// 5.字符串插值
let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message is "3 times 2.5 is 7.5"
* multiplier作為\(multiplier)被插入到一個字符串常量量中备禀。 當創(chuàng)建字符串執(zhí)行插值計算時此占位符會被替換為multiplier實際的值 *

// 6. 比較字符串
// 字符串/字符可以用等于操作符(==)和不等于操作符(!=)
let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation {
    print("These two strings are considered equal")
}
// 打印輸出 "These two strings are considered equal

集合類型

** * Swift 語言提供Arrays洲拇、Sets和Dictionaries三種基本的集合類型用來存儲集合數(shù)據(jù)。數(shù)組（Arrays）是有序數(shù)據(jù)的集曲尸。集合（Sets）是無序無重復(fù)數(shù)據(jù)的集呻待。字典（Dictionaries）是無序的鍵值對的集。** *

一队腐、數(shù)組

1.初始化方法

// 聲明數(shù)組的方式常用的是下面兩種
//1. 聲明一個不可變數(shù)組
let array = ["hhh","xixiix","gagaga"]
//2.聲明一個空的可變數(shù)組 ,用初始化方法
var arrayM = [String]()  // 或者 var arrayM = Array <String>() 這種寫法看著很麻煩，不常用

2.可變數(shù)組的基本操作（增刪改）

//1. 添加元素
arrayM.append("wawo")
arrayM.append("nihao")
arrayM.append("hello")
//2. 刪除元素
arrayM.remove(at: 0)
print(arrayM)
//3. 取出元素并附新值

arrayM[0] = "very good"
//4. 遍歷數(shù)組
//4.1 通過下標來遍歷
for i in 0..<array.count
{
    print(array[i])
}
//4.2 直接遍歷
for str in array
{
    print(str)
}
// 4.3 只遍歷前兩個元素
for name in array[0..<2]
{
    print(name)
}
//5. 數(shù)組合并
let addArray = arrayM + array  // 只有相同類型的數(shù)組可以相加

二奏篙、字典

1.初始化

var dict = ["name":"hello","age":20] as [String : Any];
print(dict["age"])
// 創(chuàng)建一個新的字典柴淘，用初始化方法
var myDictionary = [String:Any]()

2.可變字典的操作

//6.1.1添加元素
myDictionary["name"] = "petter"
myDictionary["weight"] = 60
myDictionary["height"] = 1.88
myDictionary
//6.1.2刪除元素
myDictionary.removeValue(forKey: "weight")
myDictionary
//6.1.3獲取元素迫淹，修改元素
myDictionary["name"] = "Job"
//如果字典里面沒有對應(yīng)的key會在字典里新添加一對鍵值對
myDictionary["sex"] = "male"
myDictionary
//6.1.4遍歷字典
//遍歷所有的key
for key in myDictionary.keys
{
    
}
//遍歷所有的value
for value in myDictionary.values
{
    
}
//遍歷所有的鍵值對
for (key,value) in myDictionary
{
    
}
//5.1.5合并  字典即使類型一致也不能進行相加合并
var dict1 = ["name":"peter","age":20] as [String:Any]
let dict2 = ["sex":"male","height":188] as [String:Any]

for (key,value) in dict2
{
    dict1[key] = value
}
dict1

控制流

** * Swift提供了多種流程控制結(jié)構(gòu)，包括可以多次執(zhí)行任務(wù)的while循環(huán)为严，基于特定條件選擇執(zhí)行不同代碼分支的if敛熬、guard和switch語句，還有控制流程跳轉(zhuǎn)到其他代碼位置的break和continue語句第股。還提供了for-in循環(huán)应民，用來更簡單地遍歷數(shù)組（array），字典（dictionary）夕吻，區(qū)間（range）诲锹，字符串（string）和其他序列類型。 ***

1.for in 循環(huán)

let interestingNumbers = [
    "one":[1,2,3,4],
    "two":[0,-1,5],
    "three":[9,10,4,29]
];
var largest = 0
for(kind,numbers) in interestingNumbers
{
    for number in numbers    // swift 的for in 不加括號
    {
        if(number > largest)
        {
            largest = number
        }
    }
}
print(largest)

2.While 循環(huán)
Swift 提供兩種while循環(huán)形式：

****while循環(huán)涉馅，每次在循環(huán)開始時計算條件是否符合归园；***
****repeat-while循環(huán)，每次在循環(huán)結(jié)束時計算條件是否符合稚矿。***

var num = 1
while num < 3
{
    num = num * 2
}
print(num)   // 打印結(jié)果  : 4

// do while(swift中將do 改成了 repeat) 循環(huán)放在結(jié)尾保證循環(huán)至少被執(zhí)行一次
var n = 1
repeat {
    n = n * 2
}while n < 3
print(n)  // 打印結(jié)果: 4

** 3.switch **

// switch 語句 庸诱，最基本的用法
let color = "red color"
switch color{
    case "blue":
    print("the color is blue")
    case "white":
    print("the coloe is white")
    // 這個會將后綴含有color 的結(jié)果賦給x
    case let x where x.hasSuffix("color"):
        print("the color is \(x)")
    default:
        print("no color")
}

** #匹配區(qū)間**

Paste_Image.png

// switch 也可以使用元組
// 比如 一個坐標系中的點，X軸是-2到2晤揣，Y軸也是-2到2桥爽，判斷某個點（x,y）,使用（Int,Int）類型的元組
let somePoint = (1,1)
switch somePoint {
case (0,0):
    print("is a origin point")
case (_,0): // “使用下劃線（_）來匹配所有可能的值”
    print("\(somePoint.0) 在X 軸上")
case (0,_):
    print("(\0,\(somePoint.1)) 在Y軸上")
case (-2...2,-2...2):
    print("(\(somePoint.0),\(somePoint.1) 在這個坐標系里面)")
default:
    print("不在當前坐標系范圍內(nèi)")
}

// case語句可以用where語句來判斷額外的條件
let AnotherPoint = (-1,1)
switch AnotherPoint {
case let(x,y) where x == y:
    print("x= y")
case let(x,y) where x == -y:
    print("x==-y")
case let(x,y):  // 這里用的是值綁定，“case 分支的模式允許將匹配的值綁定到一個臨時的常量或變量昧识，這些常量或變量在該 case 分支里就可以被引用了” “這三個 case 都聲明了常量x和y的占位符钠四，用于臨時獲取元組anotherPoint的一個或兩個值” “case let(x, y)聲明了一個可以匹配余下所有值的元組。這使得switch語句已經(jīng)完備了滞诺，因此不需要再書寫默認分支形导。”
    print("the point is (\(AnotherPoint.0),\(AnotherPoint.1))")
}

#復(fù)合匹配
***當多個條件可以使用同一種方法來處理時习霹，可以將這幾種可能放在同一個case后面朵耕，并且用逗號隔開。當case后面的任意一種模式匹配的時候淋叶，這條分支就會被匹配阎曹。并且，如果匹配列表過長煞檩，還可以分行書寫 ***

// switch 中的控制轉(zhuǎn)移語句 (continue, break , fallthrough ,return)
// continue  continue語句告訴一個循環(huán)體立刻停止本次循環(huán)迭代处嫌，重新開始下次循環(huán)迭代
// 下面把一串小寫字母中的元音字母和空格字符移除
let SomeCharacter = "great wall is very good"
var resultCharacter = ""
for character in SomeCharacter.characters
{
   switch character {
   case "a","e","i","o","u"," ":
       continue
   default:
       resultCharacter.append(character)
   }
}
print(resultCharacter)
/*
“在上面的代碼中，只要匹配到元音字母或者空格字符斟湃，就調(diào)用continue語句熏迹，使本次循環(huán)迭代結(jié)束，從新開始下次循環(huán)迭代凝赛。這種行為使switch匹配到元音字母和空格字符時不做處理注暗，而不是讓每一個匹配到的字符都被打印坛缕。”
*/

// Break break會立即結(jié)束整個控制流的執(zhí)行
// Fallthrough(貫穿)  在OC 中不加break會貫穿捆昏，swift中不加break也不會貫穿赚楚。如果需要貫穿就加上這個關(guān)鍵字

** #提前退出（guard）**
*** 像if語句一樣，guard的執(zhí)行取決于一個表達式的布爾值骗卜。我們可以使用guard語句來要求條件必須為真時宠页，以執(zhí)行g(shù)uard語句后的代碼。不同于if語句寇仓，一個guard語句總是有一個else從句举户，如果條件不為真則執(zhí)行else從句中的代碼。 ***

函數(shù)

1.格式

函數(shù)名 + （參數(shù)）-> 返回值類型

func greet(name:String , lunch:String) -> String {
    return "Hello \(name) lunch is \(lunch)"
}
greet(name: "steve", lunch: "cookie")    //  "Hello steve lunch is cookie"
greet(name: "job", lunch: "beef")   //  "Hello job lunch is beef"

2.參數(shù)與返回值

// 無參數(shù)
func sayHelloWorld() -> String {
    return "hello, world”
}
print(sayHelloWorld())
// 打印 "hello, world”

// 多參數(shù)
func sayHello(name:String ,message:String){
    print("\(name) 說 \(message)")
}
sayHello(name: "job", message: "我是job焚刺，很高興認識你")
// 打印 "job 說 我是job敛摘，很高興認識你\n"

// 沒有返回值的函數(shù)
func test(hello:String) {
    "hello \(hello)"
}
test(hello: "jerry") 
// 打印 "hello jerry"

// 返回多個值
func math (numbers:[Int])->(max:Int,min:Int,sum:Int)
{
    var min = numbers[0]
    var max = numbers[0]
    var sum = 0
    for number in numbers {
        if number < min {
            min = number
        }else if number > max
        {
            max = number
        }
        sum += number
    }
    return (max, min,sum)
}
math(numbers: [2,4,8,7])
// 打印   (.0 8, .1 2, .2 21)

// 帶有可變個數(shù)參數(shù)的函數(shù)  “通過在變量類型名后面加入（...）的方式來定義可變參數(shù)”
/*
 “注意： 一個函數(shù)至多能有一個可變參數(shù)，而且它必須是參數(shù)表中最后的一個乳愉。這樣做是為了避免函數(shù)調(diào)用時出現(xiàn)歧義兄淫。”
  */
func sumFunction(numbers:Int...)->Int{
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumFunction()   // 打印   0
sumFunction(numbers: 1,2,3)  // 打印   6


// 默認參數(shù)值,可以在函數(shù)體中為每個參數(shù)定義一個默認值蔓姚。當默認值被定以后捕虽，調(diào)用這個函數(shù)時可以忽略這個參數(shù)
func jion(s1:String,s2:String,joiner:String = " ")->String
{
    return s1 + joiner + s2
}
jion(s1: "hello", s2: "world", joiner: "-")      // 打印  "hello-world"
jion(s1: "hello", s2: "world") // “當這個函數(shù)被調(diào)用時，如果 joiner 的值沒有被指定坡脐，函數(shù)會使用默認值（" "）”        // 打印     "hello world"

// 函數(shù)參數(shù)默認是常量泄私，在swift3以前可以在參數(shù)列表中加var 來修飾，swift 3之后去除了這種寫法备闲，需要寫成下面這樣
func exchangeFunc ( num1: Int , num2: Int)
{
    var num1 = num1
    var num2 = num2
    let temp = num1
    num1 = num2
    num2 = temp
    print("num1:\(num1),num2:\(num2)")  
}
exchangeFunc(num1: 3, num2: 9)   //  打印 "num1:9,num2:3\n"


//輸入輸出參數(shù)  inout
// 變量參數(shù) 晌端，只能在函數(shù)體內(nèi)被修改，(默認是值傳遞)如果想要在一個函數(shù)調(diào)用結(jié)束后使修改的結(jié)果還存在恬砂，就應(yīng)該吧這個參數(shù)定義為輸入輸出參數(shù) inout 關(guān)鍵字修飾
var n1 = 3
var n2 = 8
func exchangeFunc1(num1:inout Int,num2:inout Int)
{
    let temp = num1
    num1 = num2
    num2 = temp
}
exchangeFunc1(num1:&n1, num2:&n2) // 調(diào)用的時候默認就會加上&取地址符
print("num1:\(n1),num2:\(n2)")   //  打印  "num1:8,num2:3”

// 函數(shù)類型  每個函數(shù)都有特定的函數(shù)類型咧纠，由函數(shù)的參數(shù)類型和返回類型組成
// 比如上面的exchangeFunc函數(shù)的類型是（Int,Int）-> Int ,沒有參數(shù)和返回值得類型是()->().(在swift中Void與空的元組是一樣的)
//  函數(shù)類型的使用 ，定義一個類型為函數(shù)的常量或者變量
func addTowm (a:Int,b:Int)->Int{
    return a+b
}
var myCustomeFunc :(Int,Int)->Int = addTowm
myCustomeFunc(3,6)

//同樣函數(shù)類型也可以用類型推斷泻骤，根據(jù)結(jié)果推斷其函數(shù)類型
var myCustomeFunc1 = addTowm
//有相同匹配類型的不同函數(shù)也可以被賦值給同一個變量

// 函數(shù)作為返回值(這里也是用了函數(shù)類型作為返回類型)

func returnFunc() -> ((Int) -> Int) {
    func add (number:Int)->Int{
        return number + 10
    }
    return add
}
let funcBack = returnFunc()
funcBack(10)     //  打印  20

// 函數(shù)作為參數(shù)傳入另一個函數(shù)(這里是將函數(shù)類型作為參數(shù))
func functionParameter(numbers:[Int],condition:(Int)->Bool)->Bool{
    for _num in numbers {
        if condition(_num) {
            return true
        }
    }
    return false
}
func conditionFunc (number:Int)->Bool{
    return number < 10
}
functionParameter(numbers: [2,16], condition: conditionFunc)   // 打印 true

閉包

***閉包和函數(shù)類似漆羔，可以理解成函數(shù)的簡寫形式，其本質(zhì)是匿名的可執(zhí)行代碼塊狱掂。在該代碼塊中演痒，封裝了其所處環(huán)境的所有狀態(tài)。在閉包之前聲明的所有變量和常量都可以被它捕獲趋惨。 函數(shù)和閉包都是引用類型 ,閉包表達式語法可以使用常量鸟顺、變量和 inout 類型作為參數(shù),不能提供默認值。也可以在參數(shù)列表的最后使用可 變參數(shù)器虾。元組也可以作為參數(shù)和返回值诊沪。 ***

** 1.格式**

（參數(shù)）-> (返回值類型)
//  閉包表達式語法有如下一般形式：{(參數(shù)名1:類型, 參數(shù)名2:類型) -> 返回值類型 in 功能實現(xiàn) }
/*
{ (parameters) -> returnType in
    statements
}
 */

2.使用

let addClosure = { (num1:Int, num2:Int) -> Int in 
    return num1 + num2
}
let minusClosure = { (num1:Int, num2:Int) -> Int in 
    return num1 - num2
}

3.將閉包作為函數(shù)的輸入?yún)?shù)

func calc(num1:Int, num2:Int, closure:(Int, Int) ->Int) -> Int { 
    return closure(num1, num2)
}

4.調(diào)用函數(shù)养筒，閉包作為參數(shù)傳入

let result1 = calc(100, num2: 200, closure: addClosure)  //  300
let result2 = calc(100, num2: 200, closure: minusClosure)  // -100

枚舉

1.枚舉語法
使用enum關(guān)鍵詞來創(chuàng)建枚舉并且把它們的整個定義放在一對大括號內(nèi)：
多個成員值可以出現(xiàn)在同一行上，用逗號隔開

enum SomeEnumeration {
    // 枚舉定義放在這里
}

2.枚舉的使用

enum MyEnumeration{
    case West,North,South,East
}
var enumHead = MyEnumeration.West
//enumHead = .East
enumHead = .South

switch enumHead{
case .South:
    print("yes ,you are good ")
case .West:
    print("what out of penguins")
case .East:
    print("hhh ,is the East")
case .North:
    print("is the North")
}
//  打印結(jié)果   "yes ,you are good \n"

類和對象

類是引用類型端姚，（相當于是只是引用指針指向）（=== 等價于 表示兩個類類型的常量或變量引用同一個實例 ， == 等于 表示兩個實例的值相等或相同）
1.類的定義

class shape:NSObject{
    //屬性
    // 存儲屬性
    var numberOfSide = 3
    var width = 10
    var height = 30
    
    //定義計算屬性
    var size :Int{
        return width * height
    }
    // 類屬性  通過類名進行訪問
    static var id = 8
    let type = "shape"
    // 通過重寫父類的kvc方法挤悉，在用kvc 設(shè)置類的屬性的時候可以傳入類中不存在鍵值對
    override func setValue(_ value: Any?, forUndefinedKey key: String) {
        
    }
    //swift中調(diào)用方法和屬性可以不加self
    func subDescription() -> String {
        return "the shape numberOfSide is \(numberOfSide)"
    }
    func author(name:String) -> String {
        return "the author is \(name)"
    }
}

2.對象--類的實例化

var shapeClass = shape() //初始化子類

3.對象的屬性設(shè)置與訪問

shapeClass.numberOfSide = 6 //1. 給類的存儲屬性賦值渐裸，直接賦值
shapeClass.setValuesForKeys(["numberOfSide":10]) // 2.通過kvc給類的存儲屬性賦值
shapeClass.setValue(20, forKey: "numberOfSide")
print(shapeClass.numberOfSide)
shapeClass.setValuesForKeys(["numberOfSide":30,"name":"petter"]) // 這里就不會報錯，因為上面重寫了setValue(_ value: Any?, forUndefinedKey key: String)方法
var shapeDescription = shapeClass.subDescription()
var shapeAuthor = shapeClass.author(name: "Ben")
var type = shapeClass.type

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

// 結(jié)構(gòu)體結(jié)構(gòu)體是被通過復(fù)制的方式在代碼中傳遞装悲，不使用引用計數(shù)昏鹃。 
// 結(jié)構(gòu)體和類的定義方式相似，關(guān)鍵字是struct開頭
// 結(jié)構(gòu)體和枚舉都是值類型(值類型被賦予一個變量诀诊、常量或者被傳遞給一個函數(shù)的時候洞渤，其值會被拷貝)

class SomeClass { // 聲明一個類
    var subStruct = SomeStruct()
    var name:String?
    
}

struct SomeStruct{// 聲明一個結(jié)構(gòu)體
    var width = 0
    var height = 0
}

// 結(jié)構(gòu)體和類聲明實例的方式也很相似,都采用的是構(gòu)造器語法
 let subClass = SomeClass()
 let subStruct1 = SomeStruct()

// 在swift 中可以直接設(shè)置結(jié)構(gòu)體屬性的子屬性的值，在OC 中是不允許的属瓣，需要先定義一個中間變量载迄，比如設(shè)置frame
subClass.subStruct.width = 640
print("subStruct width is now \(subClass.subStruct.width)")

// 成員逐一構(gòu)造器，用于初始化新結(jié)構(gòu)體實例中成員的屬性抡蛙。類實例沒有默認的成員逐一構(gòu)造器
let newSubStruct = SomeStruct(width:200,height:300)

// 關(guān)于值類型舉個例子

// 定義一個結(jié)構(gòu)體實例
let cnima = SomeStruct(width:1280,height:720)
// 再聲明一個HD變量护昧，將cnima的值賦給他
var HD = cnima
//修改HD的width屬性值
HD.width = 2480
print("now cnima.width is \(cnima.width)") // 打印發(fā)現(xiàn)還是1280，并未受到影響粗截，因為cnima 是一個結(jié)構(gòu)體的實例惋耙，所以HD其實就是一個cnima的拷貝副本，在幕后他們是完全不同的實例


// 枚舉
enum testEnum{
    case west,east,south
}
var currentDirectin = testEnum.west
var memberDirection = currentDirectin
memberDirection = testEnum.south
if currentDirectin == .west {
    print("currentDirection still is west")
}

參考
Swift3.0基礎(chǔ)語法快速入門
The Swift Programming Language 中文版
Wiki
移動開發(fā)
iOS