Swift-高级特性教程

// 声明可选类型
var optionalInt: Int?
var optionalString: String? = "Hello"
var optionalDouble: Double? = nil
// 检查可选值是否存在
if optionalInt != nil {
 print("optionalInt has a value: (optionalInt!)")
} else {
 print("optionalInt is nil")
}

// 强制解包（只有确定可选值存在时才能使用）
// let unwrappedInt = optionalInt! // 运行时错误，因为optionalInt是nil

let unwrappedString = optionalString! // 安全，因为optionalString有值
print(unwrappedString) // 输出: Hello

// if let 可选绑定
var optionalName: String? = "Alice"
if let name = optionalName {
 print("Hello, (name)") // 输出: Hello, Alice
 } else {
 print("Hello, unknown")
 }

// 多个可选绑定
 var optionalAge: Int? = 25

if let name = optionalName, let age = optionalAge {
 print("(name) is (age) years old") // 输出: Alice is 25 years old
 }

// 带条件的可选绑定
 if let name = optionalName, let age = optionalAge, age >= 18 {
 print("(name) is an adult") // 输出: Alice is an adult
 }

// guard let 可选绑定（用于提前退出）
 func greet(person: [String: String]) {
 guard let name = person["name"] else {
 print("No name provided")
 return
 }
print("Hello, \(name)!")
}

let user = ["name": "Bob", "age": "30"]
 greet(person: user) // 输出: Hello, Bob!

let anonymousUser = ["age": "25"]
 greet(person: anonymousUser) // 输出: No name provided

// 定义类结构
class Person {
    var residence: Residence?
}
class Residence {
 var rooms: [Room] = []
 var numberOfRooms: Int {
   return rooms.count
 }
}

class Room {
 let name: String
 init(name: String) {
self.name = name
 }
 }

// 创建实例
 let john = Person()

// 可选链调用属性
 if let roomCount = john.residence?.numberOfRooms {
 print("John’s residence has (roomCount) rooms.")
 } else {
 print("Unable to retrieve the number of rooms.") // 输出: Unable to retrieve the number of rooms.
 }

// 可选链调用方法
 john.residence?.printNumberOfRooms() // 无输出，因为residence是nil

// 可选链调用下标
 if let firstRoomName = john.residence?[0].name {
 print("The first room name is (firstRoomName).")
 } else {
 print("Unable to retrieve the first room name.") // 输出: Unable to retrieve the first room name.
 }

// 赋值给可选链
 john.residence?[0] = Room(name: "Bathroom") // 无效果，因为residence是nil

// 设置residence后再使用可选链
 let someResidence = Residence()
 someResidence.rooms.append(Room(name: "Living Room"))
 someResidence.rooms.append(Room(name: "Kitchen"))
 john.residence = someResidence

if let roomCount = john.residence?.numberOfRooms {
 print("John’s residence has (roomCount) rooms.") // 输出: John’s residence has 2 rooms.
 }

// 定义错误类型
enum VendingMachineError: Error {
    case invalidSelection
    case insufficientFunds(coinsNeeded: Int)
    case outOfStock
}
// 模拟自动售货机
 struct Item {
 let price: Int
 let count: Int
 }

class VendingMachine {
 var inventory = [
 "Candy Bar": Item(price: 12, count: 7),
 "Chips": Item(price: 10, count: 4),
 "Pretzels": Item(price: 7, count: 11)
 ]

var coinsDeposited = 0

func vend(itemNamed name: String) throws {
    guard let item = inventory[name] else {
        throw VendingMachineError.invalidSelection
    }
    
    guard item.count > 0 else {
        throw VendingMachineError.outOfStock
    }
    
    guard item.price <= coinsDeposited else {
        throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
    }
    
    coinsDeposited -= item.price
    
    var newItem = item
    newItem.count -= 1
    inventory[name] = newItem
    
    print("Dispensing \(name)")
}
}

// 使用do-try-catch处理错误
 let vendingMachine = VendingMachine()
 vendingMachine.coinsDeposited = 8

do {
 try vendingMachine.vend(itemNamed: "Candy Bar")
 } catch VendingMachineError.invalidSelection {
 print("Invalid selection.")
 } catch VendingMachineError.outOfStock {
 print("Out of stock.")
 } catch VendingMachineError.insufficientFunds(let coinsNeeded) {
 print("Insufficient funds. Please insert an additional (coinsNeeded) coins.") // 输出: Insufficient funds. Please insert an additional 4 coins.
 } catch {
 print("Unexpected error: (error).")
 }

// 传播错误
 func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
 let favoriteSnack = favoriteSnack(person: person)
 try vendingMachine.vend(itemNamed: favoriteSnack)
 }

func favoriteSnack(person: String) -> String {
 switch person {
 case "Alice": return "Chips"
 case "Bob": return "Pretzels"
 default: return "Candy Bar"
 }
 }

// try? 和 try! 表达式
 let snackName = "Chips"
 vendingMachine.coinsDeposited = 10

// try? 返回可选值，如果出错则返回nil
 if let result = try? vendingMachine.vend(itemNamed: snackName) {
 print("Successfully vended (snackName)") // 输出: Dispensing Chips
 } else {
 print("Failed to vend (snackName)")
 }

// try! 强制解包，如果出错则崩溃（只有确定不会出错时才能使用）
 vendingMachine.coinsDeposited = 10
 try! vendingMachine.vend(itemNamed: "Chips") // 输出: Dispensing Chips

// 定义类
class Person {
    let name: String
    init(name: String) {
    self.name = name
    print("\(name) is being initialized")
   }

  deinit {
    print("\(name) is being deinitialized")
  }
}

// 创建强引用
 var reference1: Person?
 var reference2: Person?
 var reference3: Person?

reference1 = Person(name: "John") // 输出: John is being initialized
 // 强引用计数: 1

reference2 = reference1
 // 强引用计数: 2

reference3 = reference1
 // 强引用计数: 3

// 释放强引用
 reference1 = nil
 // 强引用计数: 2

reference2 = nil
 // 强引用计数: 1

reference3 = nil
 // 强引用计数: 0，对象被释放
 // 输出: John is being deinitialized

// 弱引用示例
class Apartment {
    let unit: String
    weak var tenant: Person?

init(unit: String) {
    self.unit = unit
    print("Apartment \(unit) is being initialized")
}

deinit {
    print("Apartment \(unit) is being deinitialized")
}

init(name: String) {
    self.name = name
    print("Customer \(name) is being initialized")
}

deinit {
    print("Customer \(name) is being deinitialized")
}

init(number: UInt64, customer: Customer) {
    self.number = number
    self.customer = customer
    print("Credit card \(number) is being initialized")
}

deinit {
    print("Credit card \(number) is being deinitialized")
}

// 闭包导致的循环引用
class HTMLElement {
    let name: String
    let text: String?

lazy var asHTML: () -> String = {
    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

init(name: String, text: String? = nil) {
    self.name = name
    self.text = text
    print("HTMLElement \(name) is being initialized")
}

deinit {
    print("HTMLElement \(name) is being deinitialized")
}

lazy var asHTML: () -> String = {
    [weak self] in // 捕获列表，使用弱引用
    guard let self = self else { // 检查self是否存在
        return ""
    }
    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

init(name: String, text: String? = nil) {
    self.name = name
    self.text = text
    print("HTMLElement2 \(name) is being initialized")
}

deinit {
    print("HTMLElement2 \(name) is being deinitialized")
}

lazy var asHTML: () -> String = {
    [unowned self] in // 捕获列表，使用无主引用
    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

init(name: String, text: String? = nil) {
    self.name = name
    self.text = text
    print("HTMLElement3 \(name) is being initialized")
}

deinit {
    print("HTMLElement3 \(name) is being deinitialized")
}

// 关联值
enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

func evaluate() -> Int {
    switch self {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return left.evaluate() + right.evaluate()
    case .multiplication(let left, let right):
        return left.evaluate() * right.evaluate()
    }
}

// 定义带有关联类型的协议
protocol Container {
    associatedtype ItemType

mutating func append(_ item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }

mutating func push(_ item: Int) {
    items.append(item)
}

mutating func pop() -> Int {
    return items.removeLast()
}

// 遵守Container协议
typealias ItemType = Int

mutating func append(_ item: Int) {
    self.push(item)
}

var count: Int {
    return items.count
}

subscript(i: Int) -> Int {
    return items[i]
}

mutating func push(_ item: Element) {
    items.append(item)
}

mutating func pop() -> Element {
    return items.removeLast()
}

// 遵守Container协议，Swift会自动推断ItemType为Element
mutating func append(_ item: Element) {
    self.push(item)
}

var count: Int {
    return items.count
}

subscript(i: Int) -> Element {
    return items[i]
}

// 定义协议
protocol Animal {
    associatedtype Food
    func eat(_ food: Food)
    func sleep()
}

func eat(_ food: Bone) {
    print("Dog is eating \(food.type)")
}

func sleep() {
    print("Dog is sleeping")
}

func eat(_ food: Fish) {
    print("Cat is eating \(food.type)")
}

func sleep() {
    print("Cat is sleeping")
}

init<A: Animal>(_ animal: A) where A.Food == F {
    self._eat = animal.eat
    self._sleep = animal.sleep
}

func eat(_ food: F) {
    _eat(food)
}

func sleep() {
    _sleep()
}

// 获取元类型
let intType: Int.Type = Int.self
let stringType: String.Type = String.self

required init(name: String) {
    self.name = name
}

static func createInstance(name: String) -> Self {
    return self.init(name: name)
}

func introduce() {
    print("Hello, my name is \(name)")
}