swift面试知识点总结

Swift的引用类型和值类型

在 Swift 中，引用类型和值类型是两种不同的类型，它们在内存管理和行为上有显著的区别。

值类型 (Value Types)

值类型是指在赋值或传递时会复制其值的类型。Swift 中的基本值类型包括：

  • Struct（结构体）
  • Enum（枚举）
  • Tuple（元组）
  • Array（数组）
  • Dictionary（字典）
  • Set（集合）

特点：

  1. 复制行为：当你将值类型赋值给一个变量或常量，或者将其作为参数传递给函数时，会创建一个新的副本。
  2. 独立性：每个值类型的实例都是独立的，修改一个实例不会影响其他实例。

应用场景：

  • 简单数据模型：适合用于表示简单的数据结构，比如坐标、颜色等。
  • 不可变性：当你希望数据在不同的上下文中保持不变时，使用值类型是一个好选择。
  • 线程安全：由于值类型是独立的，多个线程可以安全地使用它们而不需要额外的同步。

引用类型 (Reference Types)

引用类型是指在赋值或传递时会传递对同一实例的引用的类型。Swift 中的引用类型主要是类（Class）。

特点：

  1. 共享行为：当你将引用类型赋值给一个变量或常量，或者将其作为参数传递给函数时，实际上是传递了对同一实例的引用。
  2. 共享状态：多个变量可以引用同一个实例，修改其中一个变量的属性会影响到其他引用该实例的变量。

应用场景：

  • 复杂数据模型：适合用于表示复杂的对象，比如需要继承和多态的场景。
  • 需要共享状态：当多个对象需要共享同一状态或数据时，使用引用类型是合适的。
  • 对象生命周期管理：当你需要控制对象的生命周期（例如，使用 ARC 自动管理内存）时，引用类型是必要的。

总结

  • 值类型：适合简单、独立的数据结构，具有复制和不可变的特性。
  • 引用类型：适合复杂的对象模型，具有共享和可变的特性。

在选择使用值类型还是引用类型时，可以根据具体的需求和场景来决定。一般来说，优先考虑使用值类型，只有在需要共享状态或复杂行为时才使用引用类型。

swift的值类型在传递数据会不会造车额外的内存花销

在 Swift 中，值类型（如结构体和枚举）在传递数据时确实会创建新的副本，但 Swift 采用了一种称为“写时复制”（Copy-on-Write, COW）的优化策略，以减少不必要的内存开销。

写时复制（Copy-on-Write）

  1. 基本概念：写时复制是一种优化技术，当你将值类型赋值给另一个变量或常量时，Swift 并不会立即创建一个新的副本。相反，它会创建一个对原始数据的引用，只有在需要修改数据时，才会进行实际的复制。这意味着如果你只是读取数据，而不修改它，多个变量可以共享同一个实例。

  2. 内存管理：这种方式有效地减少了内存的使用和复制的开销，尤其是在处理大型数据结构时。例如，当你将一个数组赋值给另一个变量时，实际上只是复制了指向该数组的引用，直到你尝试修改其中一个数组时，Swift 才会创建一个新的副本。

示例

以下是一个简单的示例，展示了写时复制的行为：

struct MyStruct {
    var value: Int
}

var a = MyStruct(value: 10)
var b = a // 这里并没有创建新的副本

print(a.value) // 输出 10
print(b.value) // 输出 10

b.value = 20 // 现在 b 被修改，a 仍然保持不变

print(a.value) // 输出 10
print(b.value) // 输出 20

在这个例子中，a 和 b 最初共享同一个 MyStruct 实例，只有在 b 被修改时，Swift 才会创建一个新的副本。

结论

虽然值类型在传递时会创建副本，但由于写时复制的优化，Swift 能够有效地管理内存，避免不必要的开销。因此，在大多数情况下，使用值类型是安全且高效的，尤其是在需要保持数据独立性和不可变性时。只有在极端情况下（例如，频繁的修改和大量的数据复制）才可能会遇到性能问题，但这通常可以通过合理的设计和使用来避免。

详细说下swift中class和struct的区别

在 Swift 中，class（类）和 struct（结构体）是两种重要的构造类型，它们在许多方面有相似之处，但也有一些关键的区别。以下是它们之间的详细比较：

1. 引用类型 vs 值类型

  • 类（Class）：类是引用类型。当你创建一个类的实例并将其赋值给一个变量或常量时，实际上是创建了对同一实例的引用。多个变量可以引用同一个类实例，修改其中一个变量的属性会影响到其他引用该实例的变量。

  • 结构体（Struct）：结构体是值类型。当你创建一个结构体的实例并将其赋值给一个变量或常量时，会创建一个新的副本。每个变量都有自己的独立副本，修改一个副本不会影响其他副本。

2. 继承

  • 类：类支持继承，可以从一个基类派生出子类，子类可以继承父类的属性和方法，并可以重写它们。

  • 结构体：结构体不支持继承，不能从其他结构体派生。

3. 构造器

  • 类：类可以有多个构造器，并且可以通过继承来调用父类的构造器。类的构造器可以是指定构造器或便利构造器。

  • 结构体：结构体自动提供一个成员构造器，允许你使用结构体的属性初始化实例。结构体的构造器不能继承。

4. deinit（析构器）

  • 类：类可以定义析构器（deinit），在实例被释放时执行一些清理操作。

  • 结构体：结构体没有析构器，因为它们是值类型，通常在超出作用域时自动释放。

5. 类型比较

  • 类：类的实例可以通过引用比较（=== 和 !==）来判断它们是否是同一个实例。

  • 结构体：结构体的实例通过值比较来判断它们是否相等。

6. 适用场景

  • 类：适合用于需要共享状态、继承和多态的复杂数据模型。例如，UI 组件、网络请求管理等。

  • 结构体：适合用于表示简单的数据模型，尤其是那些不需要继承的场景。常见的使用场景包括坐标、颜色、范围等。

示例代码

以下是一个简单的示例，展示了类和结构体的不同之处：

// 定义一个类
class PersonClass {
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

// 定义一个结构体
struct PersonStruct {
    var name: String
}

// 使用类
var person1 = PersonClass(name: "Alice")
var person2 = person1 // person2 引用同一个实例
person2.name = "Bob" // 修改 person2 的 name
print(person1.name) // 输出 "Bob"，因为 person1 和 person2 是同一个实例

// 使用结构体
var person3 = PersonStruct(name: "Charlie")
var person4 = person3 // person4 是 person3 的副本
person4.name = "David" // 修改 person4 的 name
print(person3.name) // 输出 "Charlie"，因为 person3 和 person4 是不同的副本

总结

  • 类 是引用类型，支持继承，具有析构器，适合复杂的对象模型。
  • 结构体 是值类型，不支持继承，自动提供成员构造器，适合简单的数据模型。

在选择使用类还是结构体时，通常建议优先考虑使用结构体，只有在需要引用语义或继承时才使用类。

swift可选类型

在 Swift 中，可选类型（Optional）是一种特殊的类型，用于表示一个变量可能有值，也可能没有值（即为 nil）。虽然 Swift 的可选类型在语法上非常直观，但它的底层实现是相对复杂的。以下是对 Swift 中可选类型底层实现的详细解释。

可选类型的底层实现

  1. 枚举类型：

    • 在 Swift 中，可选类型实际上是一个枚举（enum），定义如下：
    enum Optional<Wrapped> {
    case none
    case some(Wrapped)
}
    • 这个枚举有两个情况（case）：
      • none：表示没有值（即 nil）。
      • some(Wrapped)：表示有一个值，Wrapped 是存储的值的类型。

  2. 类型安全：

    • 由于可选类型是一个泛型枚举，它提供了类型安全的机制。每个可选类型都与其包装的类型（Wrapped）相关联，这意味着你不能将一个类型的可选值赋给另一个类型的可选值。例如，String? 和 Int? 是不同的类型。

  3. 内存管理：

    • Swift 使用自动引用计数（ARC）来管理内存。可选类型的值在内存中存储时，如果是 some，则会存储实际的值；如果是 none，则不会占用存储空间。这样，Swift 可以有效地管理内存，避免不必要的开销。

  4. 编译器优化：

    • Swift 编译器在处理可选类型时会进行一些优化。例如，在使用可选链时，编译器会生成相应的代码，以确保在访问可选值时不会导致运行时错误。

使用示例

以下是一个简单的示例，展示了如何使用可选类型：

var name: String? // 定义一个可选类型的字符串

name = "Alice" // 赋值
if let unwrappedName = name { // 安全解包
    print("Name is \(unwrappedName)")
} else {
    print("Name is nil")
}

name = nil // 设置为 nil

在这个示例中，name 是一个可选类型的字符串，最初为 nil。通过安全解包（if let），我们可以安全地访问 name 的值。

总结

  • Swift 的可选类型是一个泛型枚举，具有两个情况：none 和 some(Wrapped)。
  • 可选类型提供了类型安全的机制，确保每个可选值都与其包装的类型相关联。
  • Swift 使用自动引用计数（ARC）来管理可选类型的内存，避免不必要的开销。
  • 编译器对可选类型的处理进行了优化，以确保安全性和性能。

这种设计使得 Swift 在处理缺失值时更加安全和灵活，减少了潜在的崩溃风险。

Swift中的闭包

在 Swift 中，闭包（Closure）是一种自包含的代码块，可以在代码中被传递和使用。闭包可以捕获和存储其所在上下文中的变量和常量的引用。闭包在 Swift 中非常强大，广泛用于异步编程、回调、事件处理等场景。

闭包的基本概念

  1. 定义：

    • 闭包是一种可以在代码中被传递和使用的函数。它可以接受参数并返回值，语法上与函数类似，但没有名称。

  2. 捕获值：

    • 闭包可以捕获和存储其上下文中的变量和常量的引用。这意味着即使在闭包被定义的上下文中这些变量已经超出作用域，闭包仍然可以访问它们。

  3. 类型：

    • 闭包的类型由其参数类型和返回值类型决定。闭包可以作为函数的参数或返回值。

闭包的语法

Swift 中的闭包有三种主要形式：

  1. 全局函数：没有捕获任何值的闭包。
  2. 嵌套函数：可以捕获其外部函数的值。
  3. 闭包表达式：轻量级的语法，用于定义闭包。

闭包表达式的语法

闭包表达式的基本语法如下：

{ (parameters) -> ReturnType in
    // 闭包的主体
}
  • parameters：闭包的参数列表。
  • ReturnType：闭包的返回类型。
  • in：关键字，表示闭包主体的开始。

示例

以下是一些闭包的示例：

1. 基本闭包

let greeting = {
    print("Hello, World!")
}

greeting() // 输出 "Hello, World!"

2. 带参数和返回值的闭包

let add: (Int, Int) -> Int = { (a, b) in
    return a + b
}

let result = add(3, 5) // result 为 8

3. 捕获值的闭包

func makeIncrementer(incrementAmount: Int) -> () -> Int {
    var total = 0
    let incrementer: () -> Int = {
        total += incrementAmount
        return total
    }
    return incrementer
}

let incrementByTwo = makeIncrementer(incrementAmount: 2)
print(incrementByTwo()) // 输出 2
print(incrementByTwo()) // 输出 4

在这个例子中，incrementByTwo 闭包捕获了 total 和 incrementAmount 的值，即使 makeIncrementer 函数已经返回，incrementByTwo 仍然可以访问这些值。

闭包的简化语法

Swift 提供了一些语法糖来简化闭包的书写：

  1. 单表达式闭包：如果闭包只有一行代码，可以省略 return 关键字。
let multiply: (Int, Int) -> Int = { $0 * $1 }
  1. 参数名称简化：Swift 自动为闭包的参数提供简化名称 $0, $1, $2 等。

闭包的应用场景

  1. 回调：闭包常用于异步操作的回调，例如网络请求完成后的处理。
  2. 排序：可以使用闭包作为排序函数的参数。
  3. 事件处理：在 UI 编程中，闭包常用于处理用户交互事件。

总结

  • 闭包 是一种自包含的代码块，可以捕获和存储其上下文中的变量和常量。
  • 闭包 可以作为函数的参数或返回值，具有灵活性和强大的功能。
  • 闭包 在 Swift 中广泛应用于异步编程、回调、事件处理等场景。

通过理解闭包的概念和用法，可以更好地利用 Swift 的特性，编写出更简洁和高效的代码。

逃逸闭包和尾随闭包

在 Swift 中，逃逸闭包（Escaping Closures）和尾随闭包（Trailing Closures）是两个重要的概念，它们在使用闭包时具有不同的语法和语义。以下是对这两个概念的详细解释。

逃逸闭包（Escaping Closures）

逃逸闭包是指在函数返回后仍然可以被调用的闭包。换句话说，如果一个闭包作为参数传递给一个函数，并且在该函数返回后仍然被使用，那么这个闭包就是一个逃逸闭包。

逃逸闭包的特性

  • 存储：逃逸闭包会被存储在函数外部的某个地方（例如，类的属性或全局变量），以便在函数返回后仍然可以访问。
  • 使用 @escaping：在函数参数中声明逃逸闭包时，需要使用 @escaping 关键字。

示例

以下是一个使用逃逸闭包的示例：

class NetworkManager {
    var completionHandlers: [() -> Void] = []

    func fetchData(completion: @escaping () -> Void) {
        // 将闭包存储在数组中
        completionHandlers.append(completion)
    }
}

let manager = NetworkManager()
manager.fetchData {
    print("Data fetched!")
}

// 在某个时刻调用存储的闭包
for handler in manager.completionHandlers {
    handler() // 输出 "Data fetched!"
}

在这个例子中，fetchData 函数接受一个逃逸闭包 completion，并将其存储在 completionHandlers 数组中。即使 fetchData 函数已经返回，闭包仍然可以被调用。

尾随闭包（Trailing Closures）

尾随闭包是指在函数调用时，闭包作为最后一个参数被传递，并且可以在函数调用的圆括号外部书写。这种语法使得代码更加简洁和易读。

尾随闭包的特性

  • 简化语法：当闭包是函数的最后一个参数时，可以将其放在函数调用的括号外部。
  • 适用场景：通常用于需要传递较长闭包的情况，例如 UI 事件处理、异步操作等。

示例

以下是一个使用尾随闭包的示例：

func performOperation(with closure: () -> Void) {
    print("Before operation")
    closure() // 调用闭包
    print("After operation")
}

// 使用尾随闭包
performOperation {
    print("Performing operation...")
}

在这个例子中，performOperation 函数接受一个闭包作为参数。调用时，闭包被放在函数调用的括号外部，使得代码更加清晰。

结合使用逃逸闭包和尾随闭包

逃逸闭包和尾随闭包可以结合使用。例如，下面的代码展示了如何在一个函数中使用逃逸闭包和尾随闭包：

class TaskManager {
    var tasks: [() -> Void] = []

    func addTask(task: @escaping () -> Void) {
        tasks.append(task)
    }
}

// 使用尾随闭包
let manager = TaskManager()
manager.addTask {
    print("Task 1 executed")
}
manager.addTask {
    print("Task 2 executed")
}

// 执行所有任务
for task in manager.tasks {
    task() // 输出 "Task 1 executed" 和 "Task 2 executed"
}

在这个例子中，addTask 函数接受一个逃逸闭包作为参数，并且在调用时使用了尾随闭包的语法。

总结

  • 逃逸闭包：在函数返回后仍然可以被调用的闭包，使用 @escaping 关键字声明。
  • 尾随闭包：将闭包作为最后一个参数放在函数调用的括号外部的语法，简化了代码书写。
  • 结合使用：逃逸闭包和尾随闭包可以结合使用，使得代码更加清晰和易于维护。

理解这两个概念对于有效使用 Swift 中的闭包非常重要，尤其是在处理异步操作和回调时。

Swift泛型

在 Swift 中，泛型（Generics）是一种强大的特性，允许你编写灵活且可重用的代码。泛型使得函数、类型和数据结构能够处理任何类型，而不需要在编写代码时指定具体的类型。这种特性提高了代码的可重用性和类型安全性。

泛型的基本概念

  1. 定义：

    • 泛型允许你定义一个函数、类、结构体或枚举时不指定具体的类型，而是使用占位符类型（通常用尖括号 <T> 表示）。在使用时，可以将具体的类型传递给这些占位符。

  2. 类型参数：

    • 泛型使用类型参数来表示可以替代的类型。例如，<T> 是一个类型参数，可以在函数或类型中使用。

  3. 类型约束：

    • 你可以为泛型类型参数添加约束，以限制可以传递给泛型的类型。例如，可以指定类型参数必须遵循某个协议或是某个类的子类。

泛型的基本语法

1. 泛型函数

泛型函数的定义如下：

func swapValues<T>(a: inout T, b: inout T) {
    let temp = a
    a = b
    b = temp
}

在这个例子中，swapValues 函数接受两个相同类型的参数 a 和 b，并交换它们的值。<T> 是类型参数，表示可以接受任何类型。

2. 泛型类型

泛型类型的定义如下：

struct Stack<Element> {
    private var items: [Element] = []

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

    mutating func pop() -> Element? {
        return items.isEmpty ? nil : items.removeLast()
    }
}

在这个例子中，Stack 是一个泛型结构体，Element 是类型参数，表示栈中可以存储的元素类型。

泛型的使用场景

泛型在 Swift 中有许多实际应用场景，以下是一些常见的使用场景：

1. 数据结构

泛型常用于实现通用的数据结构，例如栈、队列、链表等。通过使用泛型，可以创建可以存储任何类型的集合。

var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
print(intStack.pop()!) // 输出 2

var stringStack = Stack<String>()
stringStack.push("Hello")
stringStack.push("World")
print(stringStack.pop()!) // 输出 "World"

2. 泛型函数

泛型函数可以用于编写通用的算法，例如排序、查找等。通过使用泛型，可以使函数适用于多种数据类型。

func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {
    for (index, element) in array.enumerated() {
        if element == value {
            return index
        }
    }
    return nil
}

let numbers = [1, 2, 3, 4, 5]
if let index = findIndex(of: 3, in: numbers) {
    print("Found at index \(index)") // 输出 "Found at index 2"
}

3. 协议和泛型

泛型与协议结合使用，可以创建灵活的 API。例如，可以定义一个协议，要求遵循该协议的类型必须实现某些功能。

protocol Container {
    associatedtype ItemType
    mutating func append(_ item: ItemType)
    var count: Int { get }
}

struct IntContainer: Container {
    var items: [Int] = []
    
    mutating func append(_ item: Int) {
        items.append(item)
    }
    
    var count: Int {
        return items.count
    }
}

在这个例子中，Container 协议使用了 associatedtype，表示遵循该协议的类型必须定义一个具体的 ItemType。

4. 类型约束

通过类型约束，可以限制泛型类型参数的类型。例如，可以要求类型参数必须是某个类的子类或遵循某个协议。

func printDescription<T: CustomStringConvertible>(item: T) {
    print(item.description)
}

struct Person: CustomStringConvertible {
    var name: String
    var description: String {
        return "Person: \(name)"
    }
}

let person = Person(name: "Alice")
printDescription(item: person) // 输出 "Person: Alice"

在这个例子中，printDescription 函数的类型参数 T 被约束为遵循 CustomStringConvertible 协议，这样可以确保传入的类型具有 description 属性。

总结

  • 泛型 是 Swift 中的一种强大特性，允许你编写灵活且可重用的代码。
  • 类型参数 和 类型约束 是泛型的核心概念，允许你定义通用的函数和类型。
  • 使用场景 包括数据结构、泛型函数、协议和类型约束等。

通过使用泛型，Swift 开发者可以编写更简洁、可维护和类型安全的代码，减少重复代码的数量，提高代码的可重用性。

堆和栈的区别，在swift中哪些类型的数据存在堆，哪些存在栈

在计算机科学中，堆（Heap）和栈（Stack）是两种不同的内存管理方式。它们在内存分配、存储方式和生命周期等方面有显著的区别。以下是堆和栈的主要区别，以及在 Swift 中哪些类型的数据存储在堆中，哪些存储在栈中。

堆和栈的区别

特性 栈（Stack） 堆（Heap）
内存分配 自动分配和释放 手动分配和释放（或通过垃圾回收）
存储方式 先进后出（LIFO） 无特定顺序
生命周期 作用域结束时自动释放 需要手动释放或由垃圾回收机制管理
速度 访问速度快 访问速度相对较慢
大小限制 通常较小，受限于线程的栈大小 通常较大，受限于系统的可用内存
数据类型 值类型（如基本数据类型、结构体等） 引用类型（如类、闭包等）

Swift 中的数据存储

在 Swift 中，数据的存储方式主要取决于其类型。以下是一些常见的数据类型及其存储位置：

1. 栈（Stack）

在 Swift 中，以下类型的数据通常存储在栈中：

  • 值类型：
    • 基本数据类型：如 Int、Float、Double、Bool 等。
    • 结构体（struct）：用户定义的结构体类型。
    • 枚举（enum）：用户定义的枚举类型。

这些类型的实例在函数调用时会被直接分配在栈上，生命周期与其作用域相同，函数返回后会自动释放。

示例：

func stackExample() {
    var a: Int = 10 // 存储在栈中
    var b: Float = 20.5 // 存储在栈中
    struct Point {
        var x: Int
        var y: Int
    }
    var point = Point(x: 5, y: 10) // 存储在栈中
}

2. 堆（Heap）

在 Swift 中，以下类型的数据通常存储在堆中：

  • 引用类型：
    • 类（class）：用户定义的类类型。
    • 闭包（closure）：捕获外部变量的闭包。
    • 函数：作为一等公民的函数类型。

这些类型的实例在堆上分配内存，生命周期由引用计数（ARC）管理，只有当没有任何强引用指向该实例时，内存才会被释放。

示例：

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

func heapExample() {
    let person = Person(name: "Alice") // 存储在堆中
    let closure: () -> Void = {
        print("Hello, \(person.name)") // 闭包捕获了 person 的引用
    }
    closure()
}

总结

  • 栈：用于存储值类型（如基本数据类型、结构体和枚举），具有自动管理内存的特性，速度快，生命周期与作用域相同。
  • 堆：用于存储引用类型（如类和闭包），需要手动管理内存（通过 ARC），速度相对较慢，生命周期由引用计数管理。

理解堆和栈的区别以及 Swift 中数据的存储方式，有助于开发者更好地管理内存，提高程序的性能和安全性。

swift中的一些属性关键字和其作用

在 Swift 中，有许多属性关键字用于定义和管理属性的行为。以下是一些常用的属性关键字及其作用：

1. var

  • 作用：用于声明一个可变的属性。可以在对象的生命周期内修改其值。
  • 示例： 
    struct Person {
    var name: String
    var age: Int
}

2. let

  • 作用：用于声明一个不可变的属性。声明后，属性的值不能被修改。
  • 示例： 
    struct Person {
    let id: Int
    var name: String
}

3. static

  • 作用：用于声明类型属性或方法，属于类型本身而不是类型的实例。可以在类、结构体或枚举中使用。
  • 示例： 
    struct Math {
    static let pi = 3.14159
    static func square(_ value: Int) -> Int {
        return value * value
    }
}

4. class

  • 作用：用于声明类属性或方法，属于类本身而不是类的实例。与 static 类似，但允许子类重写。
  • 示例： 
    class Animal {
    class var species: String {
        return "Animal"
    }
}

5. lazy

  • 作用：用于声明延迟属性。该属性在第一次访问时才会被初始化，适用于需要耗费较多资源的属性。
  • 示例： 
    class DataLoader {
    lazy var data: [String] = {
        // 复杂的初始化过程
        return ["Data1", "Data2", "Data3"]
    }()
}

6. private

  • 作用：用于限制属性的访问权限，仅在声明它的作用域内可访问。
  • 示例： 
    class BankAccount {
    private var balance: Double = 0.0
}

7. fileprivate

  • 作用：用于限制属性的访问权限，仅在同一文件内可访问。
  • 示例： 
    class BankAccount {
    fileprivate var accountNumber: String = "123456"
}

8. internal

  • 作用：默认访问级别，允许在同一模块内访问。可以省略不写。
  • 示例： 
    class BankAccount {
    var accountHolder: String = "John Doe" // 默认是 internal
}

9. public

  • 作用：用于声明属性的访问权限，允许在任何模块中访问。
  • 示例： 
    public class BankAccount {
    public var accountHolder: String
    public init(accountHolder: String) {
        self.accountHolder = accountHolder
    }
}

10. open

  • 作用：用于声明类和类成员的访问权限，允许在任何模块中访问并且可以被子类化。
  • 示例： 
    open class BankAccount {
    open var accountHolder: String
    public init(accountHolder: String) {
        self.accountHolder = accountHolder
    }
}

11. @State

  • 作用：用于 SwiftUI 中，声明一个状态属性，SwiftUI 会监视这个属性的变化并自动更新视图。
  • 示例： 
    struct ContentView: View {
    @State private var isOn: Bool = false

    var body: some View {
        Toggle("Switch", isOn: $isOn)
    }
}

12. @Binding

  • 作用：用于 SwiftUI 中，声明一个绑定属性，允许子视图与父视图共享状态。
  • 示例： 
    struct ChildView: View {
    @Binding var isOn: Bool

    var body: some View {
        Toggle("Switch", isOn: $isOn)
    }
}

13. @ObservedObject

  • 作用：用于 SwiftUI 中，声明一个观察对象属性，允许视图监视一个遵循 ObservableObject 协议的对象。
  • 示例： 
    class ViewModel: ObservableObject {
    @Published var count: Int = 0
}

struct ContentView: View {
    @ObservedObject var viewModel = ViewModel()

    var body: some View {
        Text("\(viewModel.count)")
    }
}

14. @EnvironmentObject

  • 作用：用于 SwiftUI 中，声明一个环境对象属性，允许在视图层次结构中共享数据。
  • 示例： 
    class UserSettings: ObservableObject {
    @Published var username: String = "Guest"
}

struct ContentView: View {
    @EnvironmentObject var settings: UserSettings

    var body: some View {
        Text("Hello, \(settings.username)")
    }
}

总结

这些属性关键字在 Swift 中提供了灵活性和控制力，帮助开发者管理数据的可见性、生命周期和状态。根据具体的需求选择合适的关键字，可以使代码更加清晰和易于维护。

swift属性封装器

在 Swift 中，属性封装器（Property Wrappers）是一种用于封装属性的逻辑和行为的机制。它们允许你在属性的 getter 和 setter 中添加自定义逻辑，从而简化代码并提高可重用性。属性封装器可以用于各种场景，例如数据验证、懒加载、持久化等。

1. 创建属性封装器

要创建一个属性封装器，你需要定义一个结构体或类，并实现 wrappedValue 属性。wrappedValue 是你要封装的实际值。你还可以定义其他属性和方法来扩展封装器的功能。

在 Swift 中定义一个属性封装器（propertyWrapper）时，必须实现以下两个关键部分：

var wrappedValue：这是属性封装器的核心部分，定义了被封装的值的访问方式。你需要提供一个 get 和一个 set，以便能够读取和修改封装的值。
init(wrappedValue:)：这是初始化方法，用于初始化封装器的实例。这个初始化方法接受一个参数 wrappedValue，它是被封装的初始值。

示例：简单的属性封装器

以下是一个简单的属性封装器示例，它用于确保一个整数属性的值始终为正数。

@propertyWrapper
struct Positive {
    private var value: Int

    var wrappedValue: Int {
        get { value }
        set {
            value = max(0, newValue) // 确保值为正数
        }
    }

    init(wrappedValue: Int) {
        self.value = max(0, wrappedValue) // 初始化时确保值为正数
    }
}

2. 使用属性封装器

一旦定义了属性封装器，就可以在类或结构体中使用它。使用 @ 符号来应用封装器。

示例：使用 Positive 属性封装器

struct Person {
    @Positive var age: Int // 使用 Positive 属性封装器

    init(age: Int) {
        self.age = age // 通过封装器初始化
    }
}

var person = Person(age: 25)
print(person.age) // 输出: 25

person.age = -5 // 尝试设置为负数
print(person.age) // 输出: 0

3. 属性封装器的其他功能

属性封装器可以包含其他功能，例如初始化参数、观察值变化等。

示例：带有初始化参数的属性封装器

@propertyWrapper
struct Default<T> {
    private var value: T
    private let defaultValue: T

    var wrappedValue: T {
        get { value }
        set { value = newValue }
    }

    init(wrappedValue: T, defaultValue: T) {
        self.value = wrappedValue
        self.defaultValue = defaultValue
    }

    func reset() {
        value = defaultValue // 重置为默认值
    }
}

使用带有初始化参数的属性封装器

struct Settings {
    @Default(defaultValue: "Default Name") var name: String
    @Default(defaultValue: 10) var count: Int

    mutating func reset() {
        _name.reset() // 重置 name
        _count.reset() // 重置 count
    }
}

var settings = Settings(name: "Custom Name", count: 5)
print(settings.name) // 输出: Custom Name
print(settings.count) // 输出: 5

settings.reset()
print(settings.name) // 输出: Default Name
print(settings.count) // 输出: 10

4. 结合其他属性特性

属性封装器可以与其他属性特性结合使用，例如 @State、@ObservedObject 等。

示例：结合 @State 使用属性封装器

import SwiftUI

@propertyWrapper
struct Clamped {
    private var value: Double
    private let range: ClosedRange<Double>

    var wrappedValue: Double {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }

    init(wrappedValue: Double, range: ClosedRange<Double>) {
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
        self.range = range
    }
}

struct ContentView: View {
    @Clamped(range: 0...100) var score: Double = 50

    var body: some View {
        VStack {
            Text("Score: \(score)")
            Button("Increase Score") {
                score += 10 // 尝试增加分数
            }
        }
    }
}

5. 访问封装器的原始值

在某些情况下，你可能需要访问封装器的原始值。可以通过使用 _ 前缀来访问封装器的实例。

struct Person {
    @Positive var age: Int

    func printRawValue() {
        print("Raw age value: \(_age.wrappedValue)") // 访问原始值
    }
}

var person = Person(age: 25)
person.printRawValue() // 输出: Raw age value: 25

总结

属性封装器是 Swift 中一个强大的特性，允许你封装属性的逻辑和行为。通过使用属性封装器，可以提高代码的可重用性和可读性，简化属性的管理。你可以根据需要创建自定义的属性封装器，以满足特定的需求。

Swift中的反射Mirror的作用

在 Swift 中，Mirror 是一个用于反射（Reflection）的结构体，它允许你在运行时检查和操作对象的类型信息和属性。反射是一种强大的功能，可以用于调试、序列化、动态类型检查等场景。以下是 Mirror 的一些主要作用和用法。

1. 获取类型信息

Mirror 可以用来获取对象的类型信息，包括类名、属性名、属性值等。这对于调试和日志记录非常有用。

示例：获取类型信息

struct Person {
    var name: String
    var age: Int
}

let person = Person(name: "Alice", age: 30)
let mirror = Mirror(reflecting: person)

print("Type: \(mirror.subjectType)") // 输出: Type: Person

2. 遍历属性

使用 Mirror，你可以遍历对象的所有属性及其值。这对于需要动态处理对象属性的场景非常有用。

示例：遍历属性

let mirror = Mirror(reflecting: person)

for child in mirror.children {
    if let propertyName = child.label {
        print("\(propertyName): \(child.value)")
    }
}

输出：

name: Alice
age: 30

3. 检查类型

Mirror 还可以用于检查对象的类型，判断对象是否是某个特定类型的实例。

示例：检查类型

if let firstChild = mirror.children.first {
    if firstChild.value is String {
        print("The first property is a String.")
    }
}

4. 支持嵌套类型

Mirror 可以处理嵌套类型和复杂数据结构，包括数组、字典和其他集合类型。

示例：处理数组

struct Team {
    var members: [String]
}

let team = Team(members: ["Alice", "Bob", "Charlie"])
let mirror = Mirror(reflecting: team)

for child in mirror.children {
    if let propertyName = child.label, let members = child.value as? [String] {
        print("\(propertyName): \(members)")
    }
}

输出：

members: ["Alice", "Bob", "Charlie"]

5. 用于调试

Mirror 是调试工具的一个重要组成部分，可以帮助开发者在运行时检查对象的状态和结构。这对于排查问题和理解代码的行为非常有帮助。

示例：调试输出

func debugPrint<T>(_ value: T) {
    let mirror = Mirror(reflecting: value)
    print("Debugging \(mirror.subjectType):")
    for child in mirror.children {
        if let propertyName = child.label {
            print("\(propertyName): \(child.value)")
        }
    }
}

debugPrint(person)

6. 反射与序列化

在某些情况下，Mirror 可以用于对象的序列化，将对象转换为字典或 JSON 格式。这对于实现自定义的序列化逻辑非常有用。

示例：简单的序列化

func serialize<T>(_ value: T) -> [String: Any] {
    var dict = [String: Any]()
    let mirror = Mirror(reflecting: value)

    for child in mirror.children {
        if let propertyName = child.label {
            dict[propertyName] = child.value
        }
    }
    return dict
}

let serializedPerson = serialize(person)
print(serializedPerson) // 输出: ["name": "Alice", "age": 30]

总结

Mirror 是 Swift 中一个强大的反射工具，允许你在运行时检查和操作对象的类型信息和属性。它可以用于获取类型信息、遍历属性、检查类型、调试和序列化等多种场景。虽然反射在 Swift 中并不是最常用的特性，但在某些情况下，它可以极大地提高代码的灵活性和可维护性。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容