tree_26.jpg

• 1. Playground支持Markup(類似Markdown)語言書寫注釋。

  //: [上一頁](@previous): 上一頁
  //: [下一頁](@next): 下一頁
  #：幾個對應(yīng)幾級標(biāo)題
  -：無序標(biāo)題
  1.：有序標(biāo)題
  >：筆記
  ---：分割線
  [圖片上傳失敗...(image-16af49-1606451751395)]：圖片
  [blog](http://blogzhou.top)：連接
  ** bold **：粗體
  * italic *：斜體

• 2. Let :不要求在編譯時確定颠放，但使用前必須賦值排惨。也就是實(shí)例初始化前必須有值，(存儲類型屬性除外)

// 下面代碼錯誤慈迈，因聲明時未指明常量類型
let age
age = 18

• 3. 可變參數(shù)

  public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")：形如 Any... 為可變參數(shù)

• 4. 函數(shù)可作為參數(shù)和返回值若贮。

// 作為參數(shù)

func sum(v1: Int, v2: Int) -> Int { 
    v1 + v2
}
func difference(v1: Int, v2: Int) -> Int {
    v1 - v2
}
func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) { 
    print("Result: \(mathFn(a, b))")
}
printResult(sum, 5, 2) // Result: 7
printResult(difference, 5, 2) // Result: 3

----------------------------------------------------------------------------------------------------------

// 作為返回值

func next(_ input: Int) -> Int { 
    input + 1
}
func previous(_ input: Int) -> Int {
    input - 1 
}
func forward(_ forward: Bool) -> (Int) -> Int { 
    forward ? next : previous
}
forward(true)(3) // 4
forward(false)(3) // 2
n返回值是函數(shù)類型的函數(shù)，叫做高階函數(shù)(Higher-Order Function)

• 5. 方法

// 嵌套函數(shù)痒留。
 func forward(_ forward: Bool) -> (Int) -> Int { 
    func next(_ input: Int) -> Int {
        input + 1 
    }
    func previous(_ input: Int) -> Int {
       input - 1
    }
    return forward ? next : previous
}
forward(true)(3) // 4
forward(false)(3) // 2

• 將方法賦值給var\let
  方法也可以像函數(shù)那樣，賦值給一個let或者var

struct Person {
    var age: Int
    func run(_ v: Int) { print("func run", age, v) }
    static func run(_ v: Int) { 
        print("static func run", v) 
    } 
}

let fn1 = Person.run
fn1(10) // static func run 10
let fn2: (Int) -> () = Person.run fn2(20) // static func run 20
let fn3: (Person) -> ((Int) -> ()) = Person.run 
fn3(Person(age: 18))(30) // func run 18 30

• 6. 枚舉蠢沿。

• 關(guān)聯(lián)值(Associated Values)
  • 有時將枚舉的成員值跟其他類型的值關(guān)聯(lián)存儲在一起伸头，會非常有用

enum Score {
    case points(Int)
    case grade(Character)
}

var score = Score.points(96) 
score = .grade("A")

switch score {
    case let .points(i):
        print(i, "points") 
    case let .grade(i):
        print("grade", i)
} // grade A

• 遞歸枚舉：

// indirect修飾
indirect enum ArithExpr {
    case number(Int)
    case sum(ArithExpr, ArithExpr)
    case difference(ArithExpr, ArithExpr)
}

enum ArithExpr {
    case number(Int)
    indirect case sum(ArithExpr, ArithExpr) 
    indirect case difference(ArithExpr, ArithExpr)
}
let five = ArithExpr.number(5)
let four = ArithExpr.number(4)
let two = ArithExpr.number(2)
let sum = ArithExpr.sum(five, four)
let difference = ArithExpr.difference(sum, two)

func calculate(_ expr: ArithExpr) -> Int { 
    switch expr {
      case let .number(value): 
          return value
      case let .sum(left, right):
          return calculate(left) + calculate(right)
      case let .difference(left, right):
           return calculate(left) - calculate(right)
    } 
}
calculate(difference)

• 7. 可以使用MemoryLayout獲取數(shù)據(jù)類型占用的內(nèi)存大小

enum Password {
    case number(Int, Int, Int, Int)
    case other
} 

MemoryLayout<Password>.stride // 40, 分配占用的空間大小 
MemoryLayout<Password>.size // 33, 實(shí)際用到的空間大小 
MemoryLayout<Password>.alignment // 8, 對齊參數(shù)

var pwd = Password.number(9, 8, 6, 4)
pwd = .other 
MemoryLayout.stride(ofValue: pwd) // 40 
MemoryLayout.size(ofValue: pwd) // 33
MemoryLayout.alignment(ofValue: pwd) // 8

• 8. 可選項(xiàng)(Optional)

// n 可選項(xiàng)，一般也叫可選類型舷蟀，它允許將值設(shè)置為nil 
// n在類型名稱后面加個問號? 來定義一個可選項(xiàng)
var name: String? = "Jack"
name = nil
var age: Int? // 默認(rèn)就是nil 
age = 10
age = nil
var array = [1, 15, 40, 29] 
func get(_ index: Int) -> Int? {
    if index < 0 || index >= array.count { 
        return nil
    }
    return array[index]
} 
print(get(1)) // Optional(15)
print(get(-1)) // nil 
print(get(4)) // nil

• 可選項(xiàng)是對其他類型的一層包裝恤磷，可以將它理解為一個盒子

  • 如果為nil，那么它是個空盒子
  • 如果不為nil野宜，那么盒子里裝的是:被包裝類型的數(shù)據(jù)
  • • 可選類型

• 如果要從可選項(xiàng)中取出被包裝的數(shù)據(jù)(將盒子里裝的東西取出來)扫步，需要使用感嘆號! 進(jìn)行強(qiáng)制解包

  • 如果對值為nil的可選項(xiàng)(空盒子)進(jìn)行強(qiáng)制解包，將會產(chǎn)生運(yùn)行時錯誤
    var age: Int?
    age!
    Fatal error: Unexpectedly found nil while unwrapping an Optional value

多重可選項(xiàng)

var num1: Int? = 10
var num2: Int?? = num1
var num3: Int?? = 10
 
print(num2 == num3) // true

多重可選項(xiàng)

var num1: Int? = nil
var num2: Int?? = num1
var num3: Int?? = nil
// num2中裝的是個可選類型匈子，num3中裝的是nil河胎，所以不相等。
print(num2 == num3) // false
(num2 ?? 1) ?? 2 // 2
(num3 ?? 1) ?? 2 // 1

上面代碼圖解

• 9. 空合并運(yùn)算符 ??(Nil-Coalescing Operator)

public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?

public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T 

a ?? b
a 是可選項(xiàng)
b 是可選項(xiàng) 或者 不是可選項(xiàng)
b 跟 a 的存儲類型必須相同
如果 a 不為nil虎敦，就返回 a
如果 a 為nil游岳，就返回 b
如果 b 不是可選項(xiàng)政敢，返回 a 時會自動解包

• 10. 類 和 結(jié)構(gòu)體

  • 類：引用類型，內(nèi)存在堆上胚迫，默認(rèn)只有一個無參的初始化器（定義成員時指定了初始化值喷户，否則一個沒有）。
  • 結(jié)構(gòu)體：值類型访锻，內(nèi)存根據(jù)代碼定義的地方不同而不同褪尝，默認(rèn)有好多個初始化器。