1.常量和變量
常量用let修飾，定義之后值不以修改，變量用var修飾，定義之后值可以修改。
let x = 5
let y = 10.5
var z = 15
z = 20
// 1.自動推導 常量／變量的類型會根據(jù)右側代碼的執(zhí)行結果，推導對應的類型
print(x,y,z)
// 2.不同類型之間不能直接進行計算，需要作轉換
// let a = 10
// let b = 0.5
// print(a + Int(b))
let a :Double = 10
let b = 0.5
print(a + b)
2.可選項
使用Optional或者?,表示該常量／變量可能有值，也可能沒有值。
// 1.定義可選項用 `Optional` 或者 `?`
let x:Optional = 10
let y:Int? = 20
print(x)
print(y)
// 2.可選項參與計算的時候需要解包，使用 `!` 解包，從可選值中取出對應的非空值
print(x! + y!)
3.邏輯分支
let a = 5
let b = 10
// 1.條件語句可以省略(),但是必須加上{}
if a > b {
print("a > b")
}else{
print("a < b")
}
// 2.三目的寫法與OC基本一致
a > b ?print("a > b"):print("a < b")
// 3. ?? 是一個簡單的三目，如果有值，就使用值，如果沒值，就使用 ?? 后面的值
let c :Int? = nil
print(Int(b) + (c ?? 0)) // 10
if let / var
if let 連用，用來判斷對象的值是否為nil，{}中一定有值，不需要解包。
if var 連用，{}中可以對值進行修改。
// 1.if let
let oname:String? = "xiaoshayu"
let oage:Int? = 18
// 如果{}中沒有使用，可以用_代替
if let _ = oname,
let _ = oage{
print(oname! + oage!.description)
}
// 2.if var
if var name = oname,
var age = oage{
name = "jack"
age = 20
print(name + age.description)
}
guard let
// 1.guard let 保證變量／常量一定有值，沒有值則返回。
let oname:String? = "xiaoshayu"
let oage:Int? = nil//18
guard let name = oname,
let age = oage else{
print("oname or oage is nil")
return
}
// 2.程序運行到此，name和age一定有值
print(name + age.description)
switch
// switch
// 1.可以針對任意類型的值進行分支，不再局限于整型（OC為整型）。
// 2.不需要添加break,如果需要多值，用`,`隔開。
// 3.每一個分支至少需要一條指令
// 4.在分支中定義變量／常量時不需要加{}
let num = "June"http://"January"
switch num {
case "January":
let a = 31
print("一月" + a.description + "天")
case "February":
print("二月")
case "March":
print("三月")
case "April","May","June":
print("第二季度")
default:
print("none")
}
4.for循環(huán)
// 0..<5,表示從0開始到5之間（不包含5）的數(shù)[0,5)
// 0...5,表示從0開始到5之間（包含5）的數(shù)[0,5]
for i in 0..<5 {
print(i) // 0 1 2 3 4
}
print("-----")
for i in 0...5{
print(i) // 0 1 2 3 4 5
}
5.字符串
let str = "床前明月光"
// 1.字節(jié)數(shù)
// 每個漢字事3個字節(jié)
print(str.lengthOfBytes(using: .utf8))// 15
// 2.字符串的長度
print(str.characters.count)// 5
// 3. String轉化NSString，通過.length獲取長度
let ocString = str as NSString
print(ocString.length)
// 4.字符串的遍歷
for c in str.characters{
print(c)
}
// 5. 字符串的拼接 \(常量／變量)
let a = "疑是"
let b = "地上霜"
let c = "\(a)\(b)\(20)"
print(c)
// 6. 字符串的格式化
let date = String(format:"%@年%@月%@日 %@:%@:%@",
arguments:["2019","02","23","18","33","56"])
print(date)
print("字符串的截取---")
// 7.字符串的截取
let str2:String = "舉頭望明月，低頭思故鄉(xiāng)。"
let subStr1 = str2.prefix(3) // 舉頭望
let subStr2 = str2.suffix(4) // 低頭思故鄉(xiāng)
let index1 = str2.index(str2.startIndex, offsetBy: 2)
let index2 = str2.index(str2.startIndex, offsetBy: 8)
let subStr3 = str2[index1...index2]
print(subStr1) // 舉頭望
print(subStr2) // 低頭思
print(subStr3) // 望明月，低頭思
6.數(shù)組
// 1.數(shù)組的定義 和 初始化 OC @[] Swift []
// OC 可變數(shù)組 NSMutableArray 不可變 NSArray
// Swift 可變數(shù)組 var 不可變 let
var array1 = ["Jan","Feb","Mar","Apr","May","Jun"]
print(array1)
// 初始化 [類型]()
var array2 = [String]()
array2.append("a")
print(array2)
// 2.基本數(shù)據(jù)類型不需要包裝 OC @[@(1),@(2)]
let array3 = [1,2,3,4,5]
print(array3)
// 3.數(shù)組的遍歷
// a>按照下標遍歷
for i in 0..<array1.count{
print(array1[i])
}
print("for in 遍歷")
// b>for in 遍歷
for i in array1 {
print(i)
}
print("enum 遍歷")
// c>enum 遍歷 同時遍歷下標和內(nèi)容
for e in array1.enumerated() {
print("\(e.offset) \(e.element)")
}
print("enum 遍歷2")
// d>enum 遍歷 同時遍歷下標和內(nèi)容
for (index,value) in array1.enumerated() {
print("\(index) \(value)")
}
print("反序遍歷")
// e>反序遍歷
for e in array1.reversed(){
print(e)
}
// 4.數(shù)組添加元素 .append
array2.append("b")
array2.append("c")
print(array2) // ["a", "b", "c"]
// 5.數(shù)組修改元素
array2[1] = "d"
print(array2) // ["a", "d", "c"]
// 6.數(shù)組刪除元素 .remove
array2.remove(at: 2)
print(array2) // ["a", "d"]
// 7.數(shù)組的合并 保證兩個數(shù)組類型一致
array1 += array2
// ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "a", "d"]
print(array1)
7.字典
// 1.初始化一個空字典
var dict1 = [String:AnyObject]()
// 2.字典的定義 OC @{} Swift中同樣使用 []
let dict2 = ["name":"小鯊魚","age":18] as [String : Any]
print(dict2) // ["name": "小鯊魚", "age": 18]
// 3.字典的添加元素 (有則更新鍵值對，沒有則添加)
var dict3 = ["許嵩":"清明雨上","周杰倫":"告白氣球","鄧紫棋":"光年之外"] as [String:Any]
dict3["張靚穎"] = "我的夢"
print(dict3)
// ["張靚穎": "我的夢", "許嵩": "清明雨上", "周杰倫": "告白氣球", "鄧紫棋": "光年之外"]
dict3["許嵩"] = "有何不可"
print(dict3)
// ["張靚穎": "我的夢", "許嵩": "有何不可", "周杰倫": "告白氣球", "鄧紫棋": "光年之外"]
// 4.字典元素的修改
dict3.updateValue("倒數(shù)", forKey: "鄧紫棋")
// ["張靚穎": "我的夢", "許嵩": "有何不可", "周杰倫": "告白氣球", "鄧紫棋": "倒數(shù)"]
print(dict3)
// 5.字典元素的刪除
// a>通過dict3[key] = nil 的方式刪除
dict3["鄧紫棋"] = nil
print(dict3)
// ["張靚穎": "我的夢", "許嵩": "有何不可", "周杰倫": "告白氣球"]
// b>通過.removeValue的方式刪除
dict3.removeValue(forKey: "張靚穎")
print(dict3)
// ["許嵩": "有何不可", "周杰倫": "告白氣球"]
print("字典的遍歷 --- ")
// 6.字典的遍歷
// a>
for e in dict3{
print(e)
}
//(key: "許嵩", value: "有何不可")
//(key: "周杰倫", value: "告白氣球")
// b>
for (key,value) in dict3{
print("\(key) \(value)")
}
// 許嵩 有何不可
// 周杰倫 告白氣球
print("字典的合并 ---")
// 7.字典的合并
let dict4 = ["田馥甄":"小幸運"] as [String:Any]
// 將dict4合并到dict3中
for (key,value) in dict4{
dict3[key] = value
}
print(dict3)
// ["許嵩": "有何不可", "周杰倫": "告白氣球", "田馥甄": "小幸運"]
8.函數(shù)
// 1.函數(shù)的定義格式: 函數(shù)名（形參列表）-> 返回值類型
func sum1(x:Int, y:Int) -> Int{
return x + y
}
// 2.外部參數(shù)：就是在形參前面加一個名字
// 外部參數(shù)不會影響函數(shù)內(nèi)部的細節(jié)，看起來更加直觀
// 外部參數(shù)如果使用 _ ,在外部調(diào)用函數(shù)時會省略形參的名字
func sum2(num1 x:Int, num2 y:Int) -> Int{
return x + y
}
func sum3(_ x:Int, _ y:Int) -> Int{
return x + y
}
// 3.函數(shù)的默認值
// 通過給參數(shù)設置默認值，在調(diào)用的時候，如果不設定值的，使用默認值。
func sum4(x:Int = 11, y:Int = 22) -> Int{
return x + y
}
// 4.函數(shù)無返回值的三種寫法
// a. func demo(){}
// b. func demo() -> (){}
// c. func demo() -> void{}
9.閉包
閉包類似于OC的block，但是比OC的block應用更廣，在Swift中函數(shù)時特殊的閉包。
閉包的使用場景：
- 異步執(zhí)行回調(diào)
- 控制器件回調(diào)
- 自定義視圖回調(diào)
// 閉包 格式：{(形參列表) -> 返回值類型 in 實現(xiàn)代碼}
// 1.有參數(shù)有返回值的閉包
let a = { (x: Int ,y: Int) -> Int in
return x + y
}
print(a(5,5)) // 10
// 2.有參數(shù)無返回值的閉包
let b = {(x:Int?) -> () in
print((x ?? 0))
}
b(100)
// 3.無參數(shù)無返回值的閉包
let c = {() -> () in
print("無參數(shù)無返回值的閉包")
}
c()
// 其中 ()->() in 可以省略 簡寫成 let c = { print("...")}
