字符串

在 Swift 中絕大多數的情況下，推薦使用 String 類型

使用 String 的原因

• String 是一個結構體，性能更高
  • String 目前具有了絕大多數 NSString 的功能
  • String 支持直接遍歷
• NSString 是一個 OC 對象，性能略差
• Swift 提供了 String 和 NSString 之間的無縫轉換

遍歷字符串

let str = "我要飛的更High"

for s in str {
  print(s)
}

字符串拼接

let str1 = "zhangsan"
let str2 = "lisi"
let i = 10

print(str1 + str2)
print("\(str1) \(str2) \(i)")

• 階段性小結
  • 直接在 "" 中使用 \(變量名) 的方式可以快速拼接字符串
  • 小伙伴們再也不要考慮 stringWithFormat 了

格式化字符串

for _ in 0...10 {
  let str = String(format: "zhangsan - %04d", arguments: [arc4random_uniform(100)])
  print(str)
}

• 階段性小結
  • 在實際開發中，如果需要指定字符串格式，可以使用 String(format:...) 的方式
  • 注意：后面的參數需要放在一個數組中

String & Range 的結合

以下是超級費勁的代碼

let str: String = "我要飛的更High"

var subStr = str.substringWithRange(Range<String.Index>(start: str.startIndex, end: str.endIndex))
print(subStr)

建議寫法

let str1: NSString = "我要飛的更High"
print(str1.substringWithRange(NSMakeRange(0, 3)))

邏輯分支

var i = 10

if i > 0 {
  print("OK")
}

• 階段性小結
  • Swift 中沒有 C 語言中的非零即真概念
  • 在邏輯判斷時必須顯示地指明具體的判斷條件
  • if 語句條件的 () 可以省略
  • 但是 {} 不能省略

####### 三目

var a = 10
var b = 50

var result = a > b ? a : b
print(result)

• 階段性小結
  • Swift 中的 三目 運算保持了和 OC 一致的風格

#######可選項

演練 1

let url = NSURL(string: "http://www.520it.com/")

if url != nil {
  NSURLSession.sharedSession().dataTaskWithURL(url!, completionHandler: { (data, _, _) -> Void in
    print(NSString(data: data!, encoding: NSUTF8StringEncoding))
  }).resume()
}

• 階段性小結

  • 在 Swift 中，不是所有的對象實例化方法都會返回值，在實際開發中需要注意實例化函數的返回類型，例如：

convenience init?(string URLString: String)

  * 如果有 `?` 表示改方法有可能無法實例化到正確的對象
  * 這種函數返回的對象，被稱為 `可選項`，即有可能有值，也有可能沒有值
  * 實際開發時，需要針對這種對象加以判斷，并且在分支內部使用 `!`，指明改對象確實是存在的
  * 相比在 `OC` 的開發，尤其在日常練習時，會給定一個能夠運行的值，而在實際運行時，一旦條件不滿足，會直接閃退，這樣用戶體驗會非常不好

> `Swift` 的設計者考慮到因為對類型的強制要求，會讓代碼很難看，因此提供了一個變通的解決方案

###### 演練 2

```swift
if let url = NSURL(string: "http://520it.com") {
  NSURLSession.sharedSession().dataTaskWithURL(url, completionHandler: { (data, _, _) -> Void in
    print(NSString(data: data!, encoding: NSUTF8StringEncoding))
  }).resume()
}

• 階段性小結

  • 使用 if let 常量 = 可選構造函數 的方式能夠確保分支內部常量一定是有值的
  • 并且在分支內部不再需要使用 !
  • 這是 Swift 代碼中的一個非常重要的使用技巧

• 提示

  • 盡管 Swift 提供了類型校驗的手段，但是要寫出 優雅 的 Swift 代碼，還是需要多加練習的，否則一不小心就會出現分支嵌套層次很深的代碼
  • 有關 ? 和 ! 的選擇，可以借助 Xcode 的輔助工具，但是強烈建議每次遇到提示時，要多加思考，反復揣摩

演練3

var name: String?
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

name = "lnj"
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

let l = 10
print(l + (name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding) ?? 0))

• 階段性小結
  • ?? 是一個非常有用的操作符，能夠快速對 nil 進行判斷
  • 如果對象是 nil，則使用 ?? 后面的值代替前面的 nil 值參與計算
  • 在使用 ?? 時，整個部分需要使用 () 包裝
  • 這一技巧在 UITableView 的數據源方法中尤為重要

for循環

// 傳統寫法
for var i = 0; i < 10; i++ {
  print(i)
}

------- Swift風格的 `for`-------

// 遍歷 0 ~ <10
for i in 0..<10 {
  print(i)
}

// 遍歷 0 ~ 10
for i in 0...10 {
  print(i)
}

• 階段性小結
  • Swift 中使用 in 關鍵字標示循環的范圍
  • 0..<10 表示從0到9
  • 0...10 表示從0到10
  • 注意之間不能出現空格

特殊寫法

for _ in 0...10 {
  print("hello")
}

• 階段性小結
  • 如果不關心循環本身的索引，可以使用 _ 忽略
  • 這一技巧在之前的分支演練中出現過

// 數組中保存的都是字符串
let arr = ["zhangsan", "lisi"]

// 數組中保存的是 NSObject
let arr1 = ["zhangsan", 1]

• 階段性小結
  • 數組使用 [] 定義，這一點與 OC 相同
  • 如果初始化時，所有內容類型一致，擇數組中保存的是該類型的內容
  • 如果初始化時，所有內容類型不一致，擇數組中保存的是 NSObject

數組

// 定義只能保存字符串類型數組
var array: [String]

// 初始化數組
array = ["zhangsan"]

// 添加元素
array.append("lisi")

print(array)

// 刪除元素
array.removeAtIndex(1)
print(array)

// 刪除所有元素
array.removeAll(keepCapacity: true)
print(array.capacity)

// 注意數組容量的變化
for i in 0..<10 {
  array.append("\(i)")
  print("\(array) --- \(array.capacity)")
}

// 實例化新的數組
var array2 = [String]()
array2.append("1")
array2.append("2")

// 拼接數組
array += array2

print(array)

• 階段性小結
  • 如果定義數組時指定了保存對象的類型，擇不能向數組中添加其他類型的內容
  • 可以使用 [String]()
  • let 定義的數組是不可變的
  • var 定義的數組是可變的

字典

/// 定義并實例化字典
var dict = [String: AnyObject]()

dict["name"] = "zhangsan"
dict["age"] = 18

print(dict)

// 設置相同 key，之前的數值會被覆蓋
dict["name"] = "lisi"
print(dict)

// 刪除某一個 key
dict.removeValueForKey("age")
print(dict)

dict["title"] = "manager"
print(dict)

// 遍歷字典(k, v可以隨便寫)
for (k, v) in dict {
  print("\(k) -- \(v)")
}

// 合并字典
var dict2 = ["name": "wangwu", "age": 80, "title": "boss"]
for (k, v) in dict2 {
  dict.updateValue(v, forKey: k)
}
print(dict)

函數

func sum(a: Int, b: Int) -> Int {
  return a + b
}

• 階段性小結
  • 函數定義格式：func 函數名(參數: 參數類型...) -> 返回值 { // 代碼實現 }
  • 如果沒有返回值， -> 返回值 可以省略
  • -> 是一個很有意思的符號
  • 默認情況下，在調用函數時，第一個參數名是省略的

 //強制要求參數名
func sum1(x a: Int, y b: Int) -> Int {
  return a + b
}
//省略參數名
func sum2(a: Int, _ b: Int) -> Int {
  return a + b
}

懶加載

lazy var demoView: UIView = {

  let v = UIView(frame: CGRectMake(10, 10, 100, 100))
  v.backgroundColor = UIColor.redColor()

  return v
}()

• 格式：

lazy var 變量: 類型 = { 創建變量代碼 }()

• 懶加載的寫法本質上是定義并執行一個閉包

閉包

• 閉包定義
• 閉包簡化 - 尾隨閉包
• 閉包參數
• 閉包返回值
• 閉包的循環引用

weak var weakSelf = self
demo("zhangsan") { (_) -> Int in
  print(weakSelf?.view.backgroundColor)
  return 20
}