tree_26.jpg

• 1. Playground支持Markup(类似Markdown)语言书写注释。

  //: [上一页](@previous): 上一页
  //: [下一页](@next): 下一页
  #：几个对应几级标题
  -：无序标题
  1.：有序标题
  >：笔记
  ---：分割线
  [图片上传失败...(image-16af49-1606451751395)]：图片
  [blog](http://blogzhou.top)：连接
  ** bold **：粗体
  * italic *：斜体

• 2. Let :不要求在编译时确定，但使用前必须赋值。也就是实例初始化前必须有值，(存储类型属性除外)

// 下面代码错误，因声明时未指明常量类型
let age
age = 18

• 3. 可变参数

  public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")：形如 Any... 为可变参数

• 4. 函数可作为参数和返回值。

// 作为参数

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返回值是函数类型的函数，叫做高阶函数(Higher-Order Function)

• 5. 方法

// 嵌套函数。
 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
  方法也可以像函数那样，赋值给一个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. 枚举。

• 关联值(Associated Values)
  • 有时将枚举的成员值跟其他类型的值关联存储在一起，会非常有用

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获取数据类型占用的内存大小

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

MemoryLayout<Password>.stride // 40, 分配占用的空间大小 
MemoryLayout<Password>.size // 33, 实际用到的空间大小 
MemoryLayout<Password>.alignment // 8, 对齐参数

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. 可选项(Optional)

// n 可选项，一般也叫可选类型，它允许将值设置为nil 
// n在类型名称后面加个问号? 来定义一个可选项
var name: String? = "Jack"
name = nil
var age: Int? // 默认就是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

• 可选项是对其他类型的一层包装，可以将它理解为一个盒子

  • 如果为nil，那么它是个空盒子
  • 如果不为nil，那么盒子里装的是:被包装类型的数据
  • • 可选类型

• 如果要从可选项中取出被包装的数据(将盒子里装的东西取出来)，需要使用感叹号! 进行强制解包

  • 如果对值为nil的可选项(空盒子)进行强制解包，将会产生运行时错误
    var age: Int?
    age!
    Fatal error: Unexpectedly found nil while unwrapping an Optional value

多重可选项

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

多重可选项

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. 空合并运算符 ??(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 是可选项
b 是可选项 或者 不是可选项
b 跟 a 的存储类型必须相同
如果 a 不为nil，就返回 a
如果 a 为nil，就返回 b
如果 b 不是可选项，返回 a 时会自动解包

• 10. 类 和 结构体

  • 类：引用类型，内存在堆上，默认只有一个无参的初始化器（定义成员时指定了初始化值，否则一个没有）。
  • 结构体：值类型，内存根据代码定义的地方不同而不同，默认有好多个初始化器。