Swift基础知识（三）Swift 与 Objective-C 中的自省（Introspection）对比 1. 核心概

Swift 与 Objective-C 中的自省（Introspection）对比

1. 核心概念

自省（Introspection）：在运行时检查对象的类型或是否符合特定协议的能力。
Objective-C：基于 NSObject 的类体系，主要用于检查类继承关系。
Swift：支持所有类型（类、结构体、枚举），不依赖 NSObject，且涵盖协议检查。

2. 类型检查语法与行为

特性	Objective-C	Swift
检查类继承关系	`isKindOfClass:`（判断类或子类） `isMemberOfClass:`（仅判断自身类）	`is` 操作符（判断类型或子类型）
支持类型	仅 `NSObject` 子类	所有类型（类、结构体、枚举）
协议一致性检查	`conformsToProtocol:`	`is`（检查协议类型） `as?`（转换并检查协议）
值类型支持	不支持（仅类）	支持（结构体、枚举）
泛型支持	无	支持（结合泛型类型检查）

3. 具体用法与示例

Objective-C

// 类继承检查
BOOL isView = [obj isKindOfClass:[UIView class]];       // YES（obj 是 UIView 或其子类实例）
BOOL isExactView = [obj isMemberOfClass:[UIView class]]; // NO（obj 必须是 UIView 实例）

// 协议检查
BOOL conforms = [obj conformsToProtocol:@protocol(NSCopying)];

Swift

// 类型检查
let obj: Any = "Hello"
if obj is String { // true
    print("是 String 类型")
}

// 协议检查
protocol Drawable { func draw() }
struct Circle: Drawable { func draw() { } }

let shape: Any = Circle()
if shape is Drawable { // true
    print("符合 Drawable 协议")
}

// 值类型检查
let value: Any = 100
if value is Int { // true
    print("是 Int 类型")
}

// 类型转换 + 检查
if let drawableShape = shape as? Drawable {
    drawableShape.draw()
}

4. 核心区别总结

维度	Objective-C	Swift
类型体系依赖	必须继承自 `NSObject`	不依赖任何基类，支持所有类型
检查范围	仅类（包括子类）	类、结构体、枚举、协议
协议检查	需显式调用 `conformsToProtocol:`	直接通过 `is` 或 `as?` 检查
语法简洁性	方法调用（冗长）	操作符（简洁直观）
泛型支持	无	支持泛型类型检查

5. 高级特性（Swift 独有）

模式匹配：结合 switch 语句进行类型和协议匹配。

func checkType(_ value: Any) {
    switch value {
    case is String: print("字符串类型")
    case let num as Int where num > 0: print("正整数")
    case is Drawable: print("可绘制对象")
    default: break
    }
}

元类型检查：通过 .Type 获取类型元信息。

let type: Int.Type = Int.self
let instance = type.init(10) // 创建 Int 实例

6. 使用建议

Objective-C：在维护旧项目或与 Cocoa 框架交互时使用，注意仅适用于 NSObject 子类。
Swift：在新项目中优先使用 is 和 as?，充分利用其对值类型和协议的支持，提升代码灵活性和安全性。

三、Swift 闭包（Closures）与 Objective-C Block 的对比

1. 内存分配与结构

特性	Swift 闭包	Objective-C Block
底层数据结构	闭包是捕获上下文的函数，本质是结构体	Block 是封装函数指针的结构体对象
内存位置	默认栈分配，逃逸闭包自动提升到堆	默认栈分配，需显式 `copy` 到堆
结构体布局	闭包结构体包含函数指针和捕获的上下文数据	Block 结构体包含 `isa` 指针、函数指针、捕获变量等
生命周期管理	通过引用计数（ARC）管理堆内存	手动 `copy`/`release` 或 ARC 管理堆内存

2. 变量捕获机制

特性	Swift 闭包	Objective-C Block
值类型捕获	捕获值类型的副本（深拷贝）	默认捕获值类型变量的原始值（需 `__block` 修饰允许修改）
引用类型捕获	捕获引用类型的强引用（需通过捕获列表弱化）	捕获对象的强引用（需 `__weak` 弱化）
可变性支持	通过 `var` 或 `inout` 参数捕获可变变量	需 `__block` 修饰符实现变量可变性

3. 函数执行与上下文

特性	Swift 闭包	Objective-C Block
函数指针	闭包的函数指针直接指向编译生成的函数代码	Block 的函数指针通过 `invoke` 成员指向代码
上下文管理	闭包通过结构体存储捕获的变量（值或引用）	Block 通过结构体的 `descriptor` 管理捕获变量引用计数
逃逸性处理	编译器自动检测逃逸闭包，并生成堆分配逻辑	需手动调用 `copy` 将 Block 从栈复制到堆

4. 底层实现细节

Swift 闭包

结构体表示：

// 伪代码表示闭包结构体
struct Closure<T> {
    var function: (T) -> Void  // 函数指针
    var capturedValues: [Any]  // 捕获的上下文数据
}

内存管理：
- 非逃逸闭包：栈分配，函数返回后销毁。
- 逃逸闭包：自动复制到堆，由 ARC 管理生命周期。
捕获列表优化：
- 显式声明 [weak self] 或 [unowned self]，避免隐式强引用。
- 编译器生成代码时，捕获列表直接修改闭包结构体的成员引用类型。

Objective-C Block

结构体表示：

// 伪代码表示 Block 结构体
struct Block_layout {
    void *isa;                  // 指向 Block 类型（栈/堆/全局）
    int flags;                  // 状态标记（是否被拷贝等）
    int reserved;               // 保留字段
    void (*invoke)(void *, ...); // 函数指针
    struct Block_descriptor *descriptor; // 描述符（引用计数、捕获变量等）
    // 捕获的变量数据...
};

内存管理：
- 栈 Block：默认创建在栈上，函数返回后失效。
- 堆 Block：通过 copy 操作复制到堆，由引用计数管理。
变量捕获：
- __block 修饰的变量会被包装为 Block_byref 结构体，允许跨 Block 修改。
- 对象类型变量通过 retain/release 管理引用计数（ARC 下自动处理）。

5. 性能对比

维度	Swift 闭包	Objective-C Block
内存开销	更小（结构体直接存储捕获数据）	较大（包含 `isa`、`flags` 等元数据）
执行速度	更快（直接函数指针调用）	稍慢（需通过 `invoke` 间接调用）
捕获变量修改	灵活（值类型副本独立修改）	需 `__block` 包装，性能开销较大

6. 总结

Swift 闭包：
- 更轻量：基于结构体和值语义，减少内存开销。
- 更安全：编译时检查捕获列表，避免循环引用。
- 更高效：栈分配优化 + 直接函数调用。
Objective-C Block：
- 更底层：直接操作结构体和引用计数，灵活性高。
- 兼容性：与 Cocoa 框架深度集成，适合传统代码维护。
- 显式控制：需手动管理 copy 和 __block 修饰符。

底层核心差异：

Swift 闭包是 值类型结构体，通过编译优化实现高效捕获和内存管理。
Objective-C Block 是对象，依赖运行时元数据（isa、descriptor）管理生命周期和捕获变量。