open class UIResponder : NSObject {// 响应链相关属性和方法open var next: UIResponder? { get }// 触摸事件处理方法open func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?)open func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?)open func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?)open func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?)// 按压事件处理方法open func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?)open func pressesChanged(_ presses: Set<UIPress>, with event: UIPressesEvent?)open func pressesEnded(_ presses: Set<UIPress>, with event: UIPressesEvent?)open func pressesCancelled(_ presses: Set<UIPress>, with event: UIPressesEvent?)// 远程控制事件处理方法open func remoteControlReceived(with event: UIEvent?)// 其他事件处理相关方法// ...
}

open var next: UIResponder? { get }

open func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {// 默认实现：将事件传递给下一个响应者next?.touchesBegan(touches, with: event)
}open func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {// 默认实现：将事件传递给下一个响应者next?.touchesMoved(touches, with: event)
}// 其他事件处理方法类似...

// 成为第一响应者
open func becomeFirstResponder() -> Bool// 放弃第一响应者身份
open func resignFirstResponder() -> Bool// 判断是否为第一响应者
open var isFirstResponder: Bool { get }// 判断是否可以成为第一响应者
open var canBecomeFirstResponder: Bool { get }// 判断是否可以放弃第一响应者身份
open var canResignFirstResponder: Bool { get }

// 当响应者被添加到响应链时调用
open func didMoveToParent()// 当响应者即将从响应链中移除时调用
open func willMoveToParent(_ parent: UIResponder?)// 当响应者的视图即将显示时调用
open func viewWillAppear(_ animated: Bool)// 当响应者的视图已经显示时调用
open func viewDidAppear(_ animated: Bool)// 当响应者的视图即将隐藏时调用
open func viewWillDisappear(_ animated: Bool)// 当响应者的视图已经隐藏时调用
open func viewDidDisappear(_ animated: Bool)

open class UIEvent : NSObject {// 事件类型open var type: UIEventType { get }// 事件子类型（对于某些事件类型）open var subtype: UIEventSubtype { get }// 事件发生的时间戳open var timestamp: TimeInterval { get }// 获取与事件关联的所有触摸对象open func allTouches() -> Set<UITouch>?// 其他属性和方法...
}// 事件类型枚举
@frozen public enum UIEventType : Int {case touches        // 触摸事件case motion         // 运动事件（如摇晃）case remoteControl  // 远程控制事件case presses        // 按压事件（3D Touch 等）case focus          // 焦点事件case hover          // 悬停事件case system         // 系统事件
}// 事件子类型枚举（部分示例）
@frozen public enum UIEventSubtype : Int {case none                    // 无特定子类型case motionShake             // 摇晃运动case remoteControlPlay       // 远程控制播放case remoteControlPause      // 远程控制暂停case remoteControlStop       // 远程控制停止// 其他子类型...
}

open class UITouch : NSObject {// 触摸对象的状态open var phase: UITouchPhase { get }// 触摸事件的时间戳open var timestamp: TimeInterval { get }// 触摸发生的视图open var view: UIView? { get }// 触摸发生的窗口open var window: UIWindow? { get }// 触摸点在指定视图中的位置open func location(in view: UIView?) -> CGPoint// 触摸点在上一次事件中的位置open func previousLocation(in view: UIView?) -> CGPoint// 触摸的力度（仅适用于支持压力感应的设备）open var force: CGFloat { get }// 最大可能的触摸力度open var maximumPossibleForce: CGFloat { get }// 触摸的精确位置（适用于 Apple Pencil 等精确输入设备）open var preciseLocationInView: CGPoint { get }// 触摸的精确戳记（用于区分多个触摸点）open var type: UITouchType { get }// 其他属性和方法...
}// 触摸状态枚举
@frozen public enum UITouchPhase : Int {case began         // 触摸开始case moved         // 触摸移动case stationary    // 触摸静止case ended         // 触摸结束case cancelled     // 触摸取消
}// 触摸类型枚举
@frozen public enum UITouchType : Int {case direct        // 直接触摸（手指）case indirect      // 间接触摸（如轨迹球）case stylus        // 触控笔case eraser        // 橡皮擦（Apple Pencil）
}

open class UIPress : NSObject {// 按压对象的状态open var phase: UIPressPhase { get }// 按压事件的时间戳open var timestamp: TimeInterval { get }// 按压的类型open var type: UIPressType { get }// 按压的力度（仅适用于支持压力感应的设备）open var force: CGFloat { get }// 最大可能的按压力度open var maximumPossibleForce: CGFloat { get }// 按压事件的响应者open var responder: UIResponder? { get }// 其他属性和方法...
}// 按压状态枚举
@frozen public enum UIPressPhase : Int {case began         // 按压开始case changed       // 按压变化（如力度变化）case ended         // 按压结束case cancelled     // 按压取消
}// 按压类型枚举
@frozen public enum UIPressType : Int {case upArrow       // 上箭头case downArrow     // 下箭头case leftArrow     // 左箭头case rightArrow    // 右箭头case select        // 选择按钮case playPause     // 播放/暂停按钮case menu          // 菜单按钮// 其他按压类型...
}

// 底层伪代码，展示 UITouch 对象的创建逻辑
private func createTouchObject(fromSystemEvent systemEvent: SystemEvent) -> UITouch {let touch = UITouch()// 设置触摸属性touch.phase = convertSystemPhaseToUITouchPhase(systemEvent.phase)touch.timestamp = systemEvent.timestamptouch.window = findWindowForTouch(at: systemEvent.location)touch.view = findViewForTouch(in: touch.window, at: systemEvent.location)// 设置触摸位置if let view = touch.view {touch.currentLocation = convertLocation(fromScreen: systemEvent.location, to: view)touch.previousLocation = touch.currentLocation // 初始时，上次位置与当前位置相同}// 设置其他属性...return touch
}

// 伪代码，展示事件在响应链中的传递逻辑
func dispatchEvent(_ event: UIEvent) {guard let window = application.keyWindow else { return }// 找到最适合处理事件的视图if let touchEvent = event as? UITouchEvent {let touch = touchEvent.allTouches?.firstif let location = touch?.location(in: window) {let hitView = window.hitTest(location, with: event)// 将事件发送到命中的视图if let hitView = hitView {sendEvent(event, to: hitView)} else {// 如果没有找到命中的视图，将事件发送到窗口sendEvent(event, to: window)}}} else {// 非触摸事件直接发送到窗口sendEvent(event, to: window)}
}func sendEvent(_ event: UIEvent, to responder: UIResponder) {// 根据事件类型调用相应的处理方法if let touchEvent = event as? UITouchEvent {for touch in touchEvent.allTouches ?? [] {switch touch.phase {case .began:responder.touchesBegan([touch], with: touchEvent)case .moved:responder.touchesMoved([touch], with: touchEvent)case .ended:responder.touchesEnded([touch], with: touchEvent)case .cancelled:responder.touchesCancelled([touch], with: touchEvent)default:break}}} else if let pressEvent = event as? UIPressEvent {for press in pressEvent.allPresses ?? [] {switch press.phase {case .began:responder.pressesBegan([press], with: pressEvent)case .changed:responder.pressesChanged([press], with: pressEvent)case .ended:responder.pressesEnded([press], with: pressEvent)case .cancelled:responder.pressesCancelled([press], with: pressEvent)default:break}}} else {// 其他类型的事件处理responder.remoteControlReceived(with: event)}
}

open func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {// 1. 检查视图是否被隐藏、禁用用户交互或透明度小于等于0.01if isHidden || !isUserInteractionEnabled || alpha <= 0.01 {return nil}// 2. 检查触摸点是否在视图的边界内if !bounds.contains(point) {return nil}// 3. 触摸点在视图边界内，检查子视图let subviews = self.subviews.reversed()for subview in subviews {// 将触摸点转换到子视图的坐标系let convertedPoint = convert(point, to: subview)// 递归调用子视图的 hitTest 方法if let hitView = subview.hitTest(convertedPoint, with: event) {return hitView}}// 4. 如果没有子视图包含触摸点，则返回自身return self
}

open func point(inside point: CGPoint, with event: UIEvent?) -> Bool {// 默认实现：检查点是否在视图的边界矩形内return bounds.contains(point)
}

// 示例：圆形按钮重写 point(inside:with:) 方法
override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {// 计算点到视图中心的距离let center = CGPoint(x: bounds.midX, y: bounds.midY)let radius = min(bounds.width, bounds.height) / 2let distance = sqrt(pow(point.x - center.x, 2) + pow(point.y - center.y, 2))// 如果距离小于半径，则点在圆形内部return distance <= radius
}

// 示例：自定义 hitTest 方法以优化性能
override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {// 首先检查是否在快速响应区域内if fastResponseArea.contains(point) {return self}// 对于复杂的子视图层次结构，只检查可能的候选子视图for candidateSubview in candidateSubviews {let convertedPoint = convert(point, to: candidateSubview)if let hitView = candidateSubview.hitTest(convertedPoint, with: event) {return hitView}}// 最后使用默认的 hitTest 逻辑return super.hitTest(point, with: event)
}

// UIApplication 内部处理事件的核心方法（简化伪代码）
func handleSystemEvent(_ systemEvent: GSEvent) {// 将系统事件转换为 UIEvent 对象let uiEvent = convertSystemEventToUIEvent(systemEvent)// 将事件加入到应用的事件队列中eventQueue.append(uiEvent)// 处理事件队列中的下一个事件processNextEventInQueue()
}func processNextEventInQueue() {guard let event = eventQueue.dequeue() else { return }// 判断事件类型并进行相应处理if let touchEvent = event as? UITouchEvent {// 处理触摸事件handleTouchEvent(touchEvent)} else if let pressEvent = event as? UIPressEvent {// 处理按压事件handlePressEvent(pressEvent)} else {// 处理其他类型的事件handleOtherEvent(event)}
}func handleTouchEvent(_ event: UITouchEvent) {// 获取当前的 keyWindowguard let window = keyWindow else { return }// 对每个触摸点进行 Hit-Testing，找到最适合的响应者for touch in event.allTouches ?? [] {let location = touch.location(in: window)let hitView = window.hitTest(location, with: event)// 将事件发送给命中的视图if let hitView = hitView {sendEvent(event, to: hitView)} else {// 如果没有找到命中的视图，将事件发送给窗口sendEvent(event, to: window)}}
}func sendEvent(_ event: UIEvent, to responder: UIResponder) {// 根据事件类型调用相应的处理方法if let touchEvent = event as? UITouchEvent {for touch in touchEvent.allTouches ?? [] {switch touch.phase {case .began:responder.touchesBegan([touch], with: touchEvent)case .moved:responder.touchesMoved([touch], with: touchEvent)case .ended:responder.touchesEnded([touch], with: touchEvent)case .cancelled:responder.touchesCancelled([touch], with: touchEvent)default:break}}} else if let pressEvent = event as? UIPressEvent {// 处理按压事件...} else {// 处理其他类型的事件...}
}

// UIResponder 中事件处理方法的默认实现（简化伪代码）
open func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {// 默认实现：将事件传递给下一个响应者next?.touchesBegan(touches, with: event)
}open func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {// 默认实现：将事件传递给下一个响应者next?.touchesMoved(touches, with: event)
}open func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {// 默认实现：将事件传递给下一个响应者next?.touchesEnded(touches, with: event)
}open func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {// 默认实现：将事件传递给下一个响应者next?.touchesCancelled(touches, with: event)
}

// UIButton 中事件处理方法的实现（简化伪代码）
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {// 标记按钮被按下isHighlighted = true// 更新按钮状态updateButtonAppearance()// 不调用 super，中断事件传递链// super.touchesBegan(touches, with: event)
}override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {// 标记按钮未被按下isHighlighted = false// 更新按钮状态updateButtonAppearance()// 检查触摸是否在按钮范围内if let touch = touches.first {let location = touch.location(in: self)if bounds.contains(location) {// 触摸在按钮范围内，触发点击事件sendActions(for: .touchUpInside)} else {// 触摸在按钮范围外，触发取消事件sendActions(for: .touchUpOutside)}}// 不调用 super，中断事件传递链// super.touchesEnded(touches, with: event)
}

// UIGestureRecognizer 中事件处理的核心方法（简化伪代码）
func recognizeGesture(in view: UIView, with event: UIEvent) {guard let touches = event.allTouches else { return }// 检查手势识别器的状态switch state {case .possible:// 尝试识别手势if canRecognizeGesture(with: touches) {state = .begansendActions()} else {state = .failed}case .began, .changed:// 更新手势状态if continueRecognizingGesture(with: touches) {state = .changedsendActions()} else {state = .endedsendActions()}case .ended, .failed, .cancelled:// 手势已经结束，不做处理break}
}// UIView 中重写的事件处理方法，用于集成手势识别器（简化伪代码）
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {// 首先将触摸事件发送给所有手势识别器for recognizer in gestureRecognizers ?? [] {recognizer.touchesBegan(touches, with: event)}// 如果没有手势识别器识别这个触摸事件，再将事件发送给自身if !gestureRecognizers.interferesWithEvent(touches, event: event) {super.touchesBegan(touches, with: event)}
}

open class UIGestureRecognizer : NSObject {// 手势识别器的状态open var state: UIGestureRecognizer.State { get }// 手势识别器的委托open weak var delegate: UIGestureRecognizerDelegate?// 手势识别器是否启用open var isEnabled: Bool// 手势识别器附加的视图open weak var view: UIView?// 触摸事件处理方法open func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent)open func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent)open func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent)open func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent)// 添加和移除手势处理动作open func addTarget(_ target: Any, action: Selector)open func removeTarget(_ target: Any?, action: Selector?)// 状态管理方法open func reset()open func recognizeGesture()open func require(toFail otherGestureRecognizer: UIGestureRecognizer)// 其他属性和方法...
}// 手势识别器的状态枚举
extension UIGestureRecognizer {@frozen public enum State : Int {case possible     // 可能的手势，尚未识别case began        // 手势已开始case changed      // 手势正在变化case ended        // 手势已结束case cancelled    // 手势已取消case failed       // 手势识别失败}
}

// 手势识别器状态转换的核心方法（简化伪代码）
func transitionStateForTouches(_ touches: Set<UITouch>, with event: UIEvent) {switch state {case .possible:// 尝试识别手势if canRecognizeGesture(with: touches) {state = .begansendActions()updateGestureRecognizer()} else if shouldFailGesture(with: touches) {state = .failed}case .began, .changed:// 更新手势状态if continueRecognizingGesture(with: touches) {state = .changedsendActions()updateGestureRecognizer()} else if touchesEnded {state = .endedsendActions()resetGestureRecognizer()} else if shouldCancelGesture(with: touches) {state = .cancelledsendActions()resetGestureRecognizer()}case .ended, .cancelled, .failed:// 状态已结束，不做处理break}
}func sendActions() {// 调用所有注册的目标动作targets.forEach { target, action inif target.responds(to: action) {target.perform(action, with: self)}}// 通知委托delegate?.gestureRecognizerShouldBegin?(self)
}func updateGestureRecognizer() {// 更新手势识别器的状态和属性// 例如，更新捏合手势的缩放比例、旋转角度等
}func resetGestureRecognizer() {// 重置手势识别器的状态和属性// 为下一次识别做准备
}

class UITapGestureRecognizer : UIGestureRecognizer {// 点击次数要求open var numberOfTapsRequired: Int// 触摸点数要求open var numberOfTouchesRequired: Int// 触摸事件处理方法override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesBegan(touches, with: event)// 检查触摸点数是否符合要求if touches.count != numberOfTouchesRequired {state = .failedreturn}// 记录触摸开始时间和位置startLocations = touches.reduce(into: [:]) { dict, touch indict[touch] = touch.location(in: view)}tapCount += 1}override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesEnded(touches, with: event)// 检查触摸是否在允许的范围内if touches.allSatisfy({ isInAllowableMovementRange($0) }) {if tapCount == numberOfTapsRequired {state = .ended} else {// 等待下一次点击state = .possible// 设置超时定时器，如果超时则识别失败startTapTimeoutTimer()}} else {state = .failed}}// 其他方法...
}

class UIPanGestureRecognizer : UIGestureRecognizer {// 最小移动距离要求open var minimumNumberOfTouches: Int// 最大移动距离要求open var maximumNumberOfTouches: Int// 获取当前的平移量open func translation(in view: UIView?) -> CGPoint// 设置平移量open func setTranslation(_ translation: CGPoint, in view: UIView?)// 获取当前的速度open func velocity(in view: UIView?) -> CGPoint// 触摸事件处理方法override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesBegan(touches, with: event)// 检查触摸点数是否在范围内if touches.count < minimumNumberOfTouches || touches.count > maximumNumberOfTouches {state = .failedreturn}// 记录初始位置initialLocations = touches.reduce(into: [:]) { dict, touch indict[touch] = touch.location(in: view)}}override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesMoved(touches, with event)// 计算平移量let translation = calculateTranslation(for: touches)if state == .possible {// 检查是否达到了最小移动阈值if translation.magnitude >= minimumPanDistance {state = .began}} else if state == .began || state == .changed {state = .changedupdateTranslation(translation)}}override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesEnded(touches, with event)if state == .began || state == .changed {state = .ended}}// 其他方法...
}

class UIPinchGestureRecognizer : UIGestureRecognizer {// 当前的缩放比例open var scale: CGFloat// 当前的缩放速度open var velocity: CGFloat// 触摸事件处理方法override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesBegan(touches, with event)// 捏合手势需要两个触摸点if touches.count != 2 {state = .failedreturn}// 记录初始距离let touch1 = touches.first!let touch2 = touches.dropFirst().first!initialDistance = distance(from: touch1.location(in: view), to: touch2.location(in: view))scale = 1.0}override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesMoved(touches, with event)if touches.count != 2 {state = .failedreturn}// 计算当前距离和缩放比例let touch1 = touches.first!let touch2 = touches.dropFirst().first!let currentDistance = distance(from: touch1.location(in: view), to: touch2.location(in: view))if state == .possible {// 检查是否达到了最小移动阈值let scaleDelta = currentDistance / initialDistanceif abs(scaleDelta - 1.0) >= minimumScaleDelta {state = .began}} else if state == .began || state == .changed {state = .changedscale = currentDistance / initialDistancevelocity = calculatePinchVelocity(for: touches)}}override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesEnded(touches, with event)if state == .began || state == .changed {state = .ended}}// 其他方法...
}

@objc public protocol UIGestureRecognizerDelegate : NSObjectProtocol {// 可选方法：是否应该开始识别手势@objc optional func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool// 可选方法：是否应该同时识别两个手势@objc optional func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool// 可选方法：是否应该接收触摸事件@objc optional func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool// 其他可选方法...
}// UIGestureRecognizer 中委托方法的调用（简化伪代码）
func shouldBeginGesture() -> Bool {if let delegate = delegate, let shouldBegin = delegate.gestureRecognizerShouldBegin?(self) {return shouldBegin}return true
}func shouldRecognizeSimultaneouslyWith(_ otherGestureRecognizer: UIGestureRecognizer) -> Bool {if let delegate = delegate, let shouldRecognize = delegate.gestureRecognizer?(self, shouldRecognizeSimultaneouslyWith: otherGestureRecognizer) {return shouldRecognize}return false
}func shouldReceiveTouch(_ touch: UITouch) -> Bool {if let delegate = delegate, let shouldReceive = delegate.gestureRecognizer?(self, shouldReceive: touch) {return shouldReceive}return true
}

// UIView 中集成手势识别器的事件处理方法（简化伪代码）
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {// 首先将触摸事件发送给所有手势识别器for recognizer in gestureRecognizers ?? [] {recognizer.touchesBegan(touches, with: event)}// 检查是否有手势识别器希望延迟事件传递let shouldDelayEvent = gestureRecognizers.contains { recognizer inreturn recognizer.state == .possible && recognizer.delaysTouchesBegan}if shouldDelayEvent {// 延迟事件传递，将事件放入队列delayedTouches = touchesdelayedEvent = event} else {// 没有需要延迟的手势识别器，正常处理事件super.touchesBegan(touches, with: event)}
}override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent) {// 将触摸移动事件发送给所有手势识别器for recognizer in gestureRecognizers ?? [] {recognizer.touchesMoved(touches, with: event)}// 如果没有延迟的事件，正常处理if delayedTouches == nil {super.touchesMoved(touches, with: event)}
}override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent) {// 将触摸结束事件发送给所有手势识别器for recognizer in gestureRecognizers ?? [] {recognizer.touchesEnded(touches, with: event)}// 如果没有延迟的事件，正常处理if let delayedTouches = delayedTouches, let delayedEvent = delayedEvent {// 处理延迟的事件super.touchesBegan(delayedTouches, with: delayedEvent)super.touchesEnded(touches, with: event)self.delayedTouches = nilself.delayedEvent = nil} else {super.touchesEnded(touches, with: event)}
}

// 不良实践：过多的容器视图
let containerView1 = UIView()
let containerView2 = UIView()
let containerView3 = UIView()
let button = UIButton()containerView3.addSubview(button)
containerView2.addSubview(containerView3)
containerView1.addSubview(containerView2)
view.addSubview(containerView1)// 优化实践：减少不必要的容器视图
let button = UIButton()
view.addSubview(button)

// 设置 clipsToBounds 为 true 可以优化 Hit-Testing
containerView.clipsToBounds = true

// 自定义 hitTest 方法示例
override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {// 首先检查是否在快速响应区域内if fastResponseArea.contains(point) {return self}// 对于复杂的子视图层次结构，只检查可能的候选子视图for candidateSubview in candidateSubviews {let convertedPoint = convert(point, to: candidateSubview)if let hitView = candidateSubview.hitTest(convertedPoint, with: event) {return hitView}}// 最后使用默认的 hitTest 逻辑return super.hitTest(point, with: event)
}

// 使用手势识别器替代自定义事件处理
let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap(_:)))
view.addGestureRecognizer(tapGesture)// 替代方案：重写 touchesBegan 方法
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {// 自定义触摸事件处理逻辑
}

// 设置手势识别器的依赖关系
panGesture.require(toFail: tapGesture)

// 延迟手势识别
gestureRecognizer.delaysTouchesBegan = true
gestureRecognizer.delaysTouchesEnded = true

// 不良实践：在主线程执行耗时操作
@objc func handleTap(_ gesture: UITapGestureRecognizer) {// 执行耗时操作，阻塞主线程performHeavyCalculation()
}// 优化实践：在后台线程执行耗时操作
@objc func handleTap(_ gesture: UITapGestureRecognizer) {DispatchQueue.global().async {// 在后台线程执行耗时操作self.performHeavyCalculation()DispatchQueue.main.async {// 在主线程更新 UIself.updateUI()}}
}

// 使用 Timer 实现事件批处理
@objc func handleScroll(_ scrollView: UIScrollView) {// 取消之前的定时器timer?.invalidate()// 创建新的定时器，延迟执行处理逻辑timer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: false) { [weak self] _ inself?.processScrollEvent()}
}

// 缓存计算结果
private var cachedResult: CGFloat?func calculateValue() -> CGFloat {if let cachedResult = cachedResult {return cachedResult}// 执行复杂计算let result = performComplexCalculation()cachedResult = resultreturn result
}

// 自定义性能监控示例
func measurePerformance(closure: () -> Void) -> TimeInterval {let start = CACurrentMediaTime()closure()let end = CACurrentMediaTime()return end - start
}// 使用示例
let executionTime = measurePerformance {processEvent()
}
print("事件处理耗时: \(executionTime) 秒")

// 自定义事件类型枚举
enum CustomEventType {case shakecase rotatecase customGesture
}// 自定义事件类
class CustomEvent : UIEvent {let customType: CustomEventTypelet customData: Any?init(type: CustomEventType, data: Any? = nil) {self.customType = typeself.customData = datasuper.init()}// 必须实现的父类方法override var type: UIEventType {return .system // 使用系统事件类型作为占位符}override var subtype: UIEventSubtype {return .none}override var timestamp: TimeInterval {return Date().timeIntervalSince1970}override func allTouches() -> Set<UITouch>? {return nil}
}// 自定义事件处理代理协议
protocol CustomEventDelegate : AnyObject {func handleCustomEvent(_ event: CustomEvent)
}// 在视图控制器中使用自定义事件
class CustomEventViewController : UIViewController {weak var delegate: CustomEventDelegate?func sendCustomEvent(type: CustomEventType, data: Any? = nil) {let event = CustomEvent(type: type, data: data)// 将自定义事件发送给响应链if let responder = view.next {// 这里可以根据需要调用响应者的特定方法responder.sendActions(for: .valueChanged)}// 或者通过代理通知delegate?.handleCustomEvent(event)}
}

class MultiTouchView : UIView {// 存储每个触摸点的信息private var touchLocations: [UITouch: CGPoint] = [:]override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {super.touchesBegan(touches, with: event)// 处理新的触摸点for touch in touches {let location = touch.location(in: self)touchLocations[touch] = location// 处理单点触摸开始handleSingleTouchBegan(at: location, touch: touch)}// 处理多点触控开始if touches.count > 1 {handleMultiTouchBegan(with: touches)}}override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {super.touchesMoved(touches, with event)for touch in touches {let location = touch.location(in: self)let previousLocation = touch.previousLocation(in: self)// 更新触摸点位置touchLocations[touch] = location// 处理单点触摸移动handleSingleTouchMoved(from: previousLocation, to: location, touch: touch)}// 处理多点触控移动if touches.count > 1 {handleMultiTouchMoved(with: touches)}}override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {super.touchesEnded(touches, with event)for touch in touches {// 移除结束的触摸点touchLocations.removeValue(forKey: touch)// 处理单点触摸结束handleSingleTouchEnded(at: touch.location(in: self), touch: touch)}// 处理多点触控结束if touches.count > 1 {handleMultiTouchEnded(with: touches)}}override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {super.touchesCancelled(touches, with event)// 处理触摸取消，类似于触摸结束touchesEnded(touches, with: event)}// 单点触摸处理方法private func handleSingleTouchBegan(at location: CGPoint, touch: UITouch) {// 处理单点触摸开始逻辑}private func handleSingleTouchMoved(from previousLocation: CGPoint, to location: CGPoint, touch: UITouch) {// 处理单点触摸移动逻辑let deltaX = location.x - previousLocation.xlet deltaY = location.y - previousLocation.y// 例如：移动视图transform = transform.translatedBy(x: deltaX, y: deltaY)}private func handleSingleTouchEnded(at location: CGPoint, touch: UITouch) {// 处理单点触摸结束逻辑}// 多点触控处理方法private func handleMultiTouchBegan(with touches: Set<UITouch>) {// 处理多点触控开始逻辑}private func handleMultiTouchMoved(with touches: Set<UITouch>) {// 处理多点触控移动逻辑guard touches.count == 2 else { return }let touch1 = touches.first!let touch2 = touches.dropFirst().first!let currentPoint1 = touch1.location(in: self)let currentPoint2 = touch2.location(in: self)// 计算两点之间的距离和角度let currentDistance = distance(from: currentPoint1, to: currentPoint2)let currentAngle = angle(from: currentPoint1, to: currentPoint2)// 可以根据距离和角度实现缩放、旋转等操作}private func handleMultiTouchEnded(with touches: Set<UITouch>) {// 处理多点触控结束逻辑}// 辅助方法：计算两点之间的距离private func distance(from point1: CGPoint, to point2: CGPoint) -> CGFloat {return sqrt(pow(point2.x - point1.x, 2) + pow(point2.y - point1.y, 2))}// 辅助方法：计算两点之间的角度private func angle(from point1: CGPoint, to point2: CGPoint) -> CGFloat {return atan2(point2.y - point1.y, point2.x - point1.x)}
}

class RemoteControlViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()// 注册接收远程控制事件UIApplication.shared.beginReceivingRemoteControlEvents()// 确保视图控制器是第一响应者becomeFirstResponder()}override func viewWillDisappear(_ animated: Bool) {super.viewWillDisappear(animated)// 停止接收远程控制事件UIApplication.shared.endReceivingRemoteControlEvents()// 放弃第一响应者身份resignFirstResponder()}// 必须重写此方法以允许视图控制器成为第一响应者override var canBecomeFirstResponder: Bool {return true}// 处理远程控制事件override func remoteControlReceived(with event: UIEvent?) {guard let event = event else { return }switch event.subtype {case .remoteControlPlay:// 处理播放事件handlePlayCommand()case .remoteControlPause:// 处理暂停事件handlePauseCommand()case .remoteControlStop:// 处理停止事件handleStopCommand()case .remoteControlNextTrack:// 处理下一曲事件handleNextTrackCommand()case .remoteControlPreviousTrack:// 处理上一曲事件handlePreviousTrackCommand()case .remoteControlTogglePlayPause:// 处理播放/暂停切换事件handleTogglePlayPauseCommand()default:// 处理其他类型的远程控制事件break}}// 远程控制命令处理方法private func handlePlayCommand() {// 实现播放逻辑}private func handlePauseCommand() {// 实现暂停逻辑}private func handleStopCommand() {// 实现停止逻辑}private func handleNextTrackCommand() {// 实现下一曲逻辑}private func handlePreviousTrackCommand() {// 实现上一曲逻辑}private func handleTogglePlayPauseCommand() {// 实现播放/暂停切换逻辑}
}

class ThreadSafeViewController : UIViewController {// 用于存储后台线程处理结果的队列private let resultQueue = DispatchQueue(label: "com.example.resultQueue")private var backgroundResults: [Any] = []override func viewDidLoad() {super.viewDidLoad()// 创建一个按钮用于触发事件let button = UIButton(type: .system)button.setTitle("执行后台任务", for: .normal)button.addTarget(self, action: #selector(handleButtonTap), for: .touchUpInside)button.frame = CGRect(x: 100, y: 200, width: 200, height: 50)view.addSubview(button)}@objc private func handleButtonTap() {// 在后台线程执行耗时操作DispatchQueue.global().async {// 模拟耗时操作let result = self.performHeavyCalculation()// 将结果添加到队列self.resultQueue.async {self.backgroundResults.append(result)// 在主线程更新 UIDispatchQueue.main.async {self.updateUI(with: result)}}}}private func performHeavyCalculation() -> String {// 模拟耗时计算Thread.sleep(forTimeInterval: 2.0)return "计算结果: \(arc4random_uniform(100))"}private func updateUI(with result: String) {// 更新 UI 必须在主线程执行let alert = UIAlertController(title: "计算完成", message: result, preferredStyle: .alert)alert.addAction(UIAlertAction(title: "确定", style: .default))present(alert, animated: true)}// 线程安全的事件处理override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {super.touchesBegan(touches, with event)// 确保在主线程执行 UI 操作DispatchQueue.main.async {// 更新 UIself.view.backgroundColor = UIColor.random}}
}// 扩展 UIColor 以生成随机颜色
extension UIColor {static var random: UIColor {return UIColor(red: CGFloat.random(in: 0...1),green: CGFloat.random(in: 0...1),blue: CGFloat.random(in: 0...1),alpha: 1.0)}
}

class AnimationViewController : UIViewController {private var animatedView: UIView!private var isAnimating = falseoverride func viewDidLoad() {super.viewDidLoad()// 创建一个可动画的视图animatedView = UIView(frame: CGRect(x: 100, y: 200, width: 100, height: 100))animatedView.backgroundColor = .redview.addSubview(animatedView)// 添加点击手势let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))animatedView.addGestureRecognizer(tapGesture)// 添加长按手势let longPressGesture = UILongPressGestureRecognizer(target: self, action: #selector(handleLongPress))animatedView.addGestureRecognizer(longPressGesture)}@objc private func handleTap() {if isAnimating {stopAnimation()} else {startBounceAnimation()}}@objc private func handleLongPress(gesture: UILongPressGestureRecognizer) {switch gesture.state {case .began:startScaleAnimation()case .ended, .cancelled:resetScale()default:break}}private func startBounceAnimation() {isAnimating = trueUIView.animate(withDuration: 0.5, delay: 0, options: [.repeat, .autoreverse], animations: {self.animatedView.transform = CGAffineTransform(scaleX: 1.2, y: 1.2)})}private func stopAnimation() {isAnimating = falseanimatedView.layer.removeAllAnimations()animatedView.transform = .identity}private func startScaleAnimation() {UIView.animate(withDuration: 0.3) {self.animatedView.transform = CGAffineTransform(scaleX: 1.5, y: 1.5)}}private func resetScale() {UIView.animate(withDuration: 0.3) {self.animatedView.transform = .identity}}// 拖动手势处理override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {super.touchesBegan(touches, with event)if let touch = touches.first, touch.view == animatedView {// 记录触摸开始位置startLocation = touch.location(in: view)}}private var startLocation: CGPoint?override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {super.touchesMoved(touches, with event)if let touch = touches.first, touch.view == animatedView, let startLocation = startLocation {// 计算移动距离let currentLocation = touch.location(in: view)let deltaX = currentLocation.x - startLocation.xlet deltaY = currentLocation.y - startLocation.y// 使用动画平滑移动视图UIView.animate(withDuration: 0.1) {self.animatedView.center = CGPoint(x: self.animatedView.center.x + deltaX,y: self.animatedView.center.y + deltaY)}// 更新起始位置self.startLocation = currentLocation}}
}

class ViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()// 创建按钮let button = UIButton(type: .system)button.setTitle("点击我", for: .normal)button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)view.addSubview(button)}@objc func buttonTapped() {// 处理按钮点击事件}
}

class TableViewController : UITableViewController, UITableViewDelegate, UITableViewDataSource {override func viewDidLoad() {super.viewDidLoad()tableView.delegate = selftableView.dataSource = self}// 实现 UITableViewDataSource 协议方法func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {return 10}func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)cell.textLabel?.text = "Row \(indexPath.row)"return cell}// 实现 UITableViewDelegate 协议方法处理单元格点击事件func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {// 处理单元格点击事件}
}

class CustomButton : UIButton {var onTap: (() -> Void)?override init(frame: CGRect) {super.init(frame: frame)commonInit()}required init?(coder: NSCoder) {super.init(coder: coder)commonInit()}private func commonInit() {addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)}@objc private func buttonTapped() {onTap?()}
}// 在视图控制器中使用
class ViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()let customButton = CustomButton()customButton.onTap = { [weak self] inself?.handleButtonTap()}view.addSubview(customButton)}private func handleButtonTap() {// 处理按钮点击事件}
}

class NotificationViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()// 注册通知NotificationCenter.default.addObserver(self,selector: #selector(handleNotification),name: .UIApplicationDidBecomeActive,object: nil)}deinit {// 移除通知观察者NotificationCenter.default.removeObserver(self)}@objc func handleNotification() {// 处理通知事件}
}

// 定义代理协议
protocol CustomViewDelegate : AnyObject {func customViewDidTap(_ view: CustomView)
}class CustomView : UIView {weak var delegate: CustomViewDelegate?override init(frame: CGRect) {super.init(frame: frame)setupView()}required init?(coder: NSCoder) {super.init(coder: coder)setupView()}private func setupView() {// 添加点击手势let tapGesture = UITapGestureRecognizer(target: self, action: #selector(viewTapped))addGestureRecognizer(tapGesture)}@objc private func viewTapped() {// 通知代理delegate?.customViewDidTap(self)}
}// 在视图控制器中使用
class ViewController : UIViewController, CustomViewDelegate {override func viewDidLoad() {super.viewDidLoad()let customView = CustomView()customView.delegate = selfview.addSubview(customView)}func customViewDidTap(_ view: CustomView) {// 处理自定义视图的点击事件}
}

class CustomView : UIView {var onTap: (() -> Void)?override init(frame: CGRect) {super.init(frame: frame)setupView()}required init?(coder: NSCoder) {super.init(coder: coder)setupView()}private func setupView() {// 添加点击手势let tapGesture = UITapGestureRecognizer(target: self, action: #selector(viewTapped))addGestureRecognizer(tapGesture)}@objc private func viewTapped() {// 调用闭包onTap?()}
}// 在视图控制器中使用
class ViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()let customView = CustomView()customView.onTap = { [weak self] inself?.handleCustomViewTap()}view.addSubview(customView)}private func handleCustomViewTap() {// 处理自定义视图的点击事件}
}

class CustomView : UIView {override init(frame: CGRect) {super.init(frame: frame)setupView()}required init?(coder: NSCoder) {super.init(coder: coder)setupView()}private func setupView() {// 添加点击手势let tapGesture = UITapGestureRecognizer(target: self, action: #selector(viewTapped))addGestureRecognizer(tapGesture)}@objc private func viewTapped() {// 发布通知NotificationCenter.default.post(name: .customViewTapped,object: self)}
}// 定义通知名称
extension Notification.Name {static let customViewTapped = Notification.Name("customViewTapped")
}// 在视图控制器中使用
class ViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()// 注册通知NotificationCenter.default.addObserver(self,selector: #selector(handleCustomViewTapNotification),name: .customViewTapped,object: nil)}deinit {// 移除通知观察者NotificationCenter.default.removeObserver(self)}@objc private func handleCustomViewTapNotification(_ notification: Notification) {// 处理自定义视图的点击事件if let customView = notification.object as? CustomView {// 使用 customView 进行处理}}
}

class SceneDelegate : UIResponder, UIWindowSceneDelegate {var window: UIWindow?func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {guard let windowScene = (scene as? UIWindowScene) else { return }// 创建窗口window = UIWindow(windowScene: windowScene)// 设置根视图控制器let viewController = ViewController()window?.rootViewController = viewController// 显示窗口window?.makeKeyAndVisible()}func sceneDidDisconnect(_ scene: UIScene) {// 处理窗口场景断开连接事件}func sceneDidBecomeActive(_ scene: UIScene) {// 处理窗口场景激活事件}func sceneWillResignActive(_ scene: UIScene) {// 处理窗口场景即将失活事件}func sceneWillEnterForeground(_ scene: UIScene) {// 处理窗口场景即将进入前台事件}func sceneDidEnterBackground(_ scene: UIScene) {// 处理窗口场景进入后台事件}
}

// 使用通知中心实现窗口间通信
// 在发送窗口中
NotificationCenter.default.post(name: .windowMessageSent,object: nil,userInfo: ["message": "Hello from another window"]
)// 在接收窗口中
NotificationCenter.default.addObserver(self,selector: #selector(handleWindowMessage),name: .windowMessageSent,object: nil
)@objc func handleWindowMessage(_ notification: Notification) {if let message = notification.userInfo?["message"] as? String {// 处理接收到的消息}
}// 定义通知名称
extension Notification.Name {static let windowMessageSent = Notification.Name("windowMessageSent")
}

// 在多窗口应用中处理共享资源
class SharedResourceManager {static let shared = SharedResourceManager()private init() {}private var counter = 0func incrementCounter() {counter += 1// 通知所有窗口计数器已更新NotificationCenter.default.post(name: .counterUpdated, object: nil)}func getCounter() -> Int {return counter}
}// 在窗口控制器中
class WindowViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()// 注册通知NotificationCenter.default.addObserver(self,selector: #selector(updateUI),name: .counterUpdated,object: nil)}deinit {// 移除通知观察者NotificationCenter.default.removeObserver(self)}@objc func updateUI() {// 更新 UI 显示最新的计数器值let counter = SharedResourceManager.shared.getCounter()// 更新界面显示}@IBAction func incrementButtonTapped(_ sender: UIButton) {// 增加计数器值SharedResourceManager.shared.incrementCounter()}
}// 定义通知名称
extension Notification.Name {static let counterUpdated = Notification.Name("counterUpdated")
}

class SplitViewController : UIViewController {override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {super.viewWillTransition(to size, with: coordinator)// 处理布局变化coordinator.animate(alongsideTransition: { [weak self] _ inself?.updateLayout(for: size)})}private func updateLayout(for size: CGSize) {// 根据新的尺寸更新布局if size.width < size.height {// 竖屏布局} else {// 横屏布局}}
}

class SplitViewController : UIViewController {override func viewDidAppear(_ animated: Bool) {super.viewDidAppear(animated)// 注册通知监听应用激活状态NotificationCenter.default.addObserver(self,selector: #selector(handleAppActiveStateChange),name: .UIApplicationDidBecomeActive,object: nil)NotificationCenter.default.addObserver(self,selector: #selector(handleAppActiveStateChange),name: .UIApplicationWillResignActive,object: nil)}deinit {// 移除通知观察者NotificationCenter.default.removeObserver(self)}@objc func handleAppActiveStateChange(_ notification: Notification) {if notification.name == .UIApplicationDidBecomeActive {// 应用变为活跃状态，可能是用户切换到了本应用startBackgroundTasks()} else if notification.name == .UIApplicationWillResignActive {// 应用即将失去活跃状态，可能是用户切换到了另一个应用pauseBackgroundTasks()}}
}

// 使用 UserDefaults 实现 App Group 数据共享
class SharedDataManager {static let shared = SharedDataManager()private let userDefaults: UserDefaultsprivate init() {// 获取 App Group 的 UserDefaultsuserDefaults = UserDefaults(suiteName: "group.com.example.shared") ?? UserDefaults.standard}var sharedData: String? {get {return userDefaults.string(forKey: "sharedData")}set {userDefaults.set(newValue, forKey: "sharedData")userDefaults.synchronize()}}
}// 在应用 A 中设置共享数据
SharedDataManager.shared.sharedData = "Hello from App A"// 在应用 B 中获取共享数据
if let data = SharedDataManager.shared.sharedData {// 使用共享数据
}

class KeyboardViewController : UIViewController {override func viewDidLoad() {super.viewDidLoad()// 注册键盘事件通知NotificationCenter.default.addObserver(self,selector: #selector(keyboardWillShow),name: UIResponder.keyboardWillShowNotification,object: nil)NotificationCenter.default.addObserver(self,selector: #selector(keyboardWillHide),name: UIResponder.keyboardWillHideNotification,object: nil)}deinit {// 移除通知观察者NotificationCenter.default.removeObserver(self)}@objc func keyboardWillShow(_ notification: Notification) {// 获取键盘信息if let keyboardFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect {// 调整视图布局以避免被键盘遮挡adjustViewForKeyboard(keyboardFrame: keyboardFrame, showing: true)}}@objc func keyboardWillHide(_ notification: Notification) {// 恢复视图布局adjustViewForKeyboard(keyboardFrame: .zero, showing: false)}private func adjustViewForKeyboard(keyboardFrame: CGRect, showing: Bool) {// 计算键盘高度let keyboardHeight = keyboardFrame.height// 调整滚动视图的 contentInsetif let scrollView = view as? UIScrollView {if showing {scrollView.contentInset.bottom = keyboardHeightscrollView.scrollIndicatorInsets.bottom = keyboardHeight} else {scrollView.contentInset.bottom = 0scrollView.scrollIndicatorInsets.bottom = 0}}}
}

class KeyboardViewController : UIViewController, UITextFieldDelegate {@IBOutlet weak var textField: UITextField!@IBOutlet weak var scrollView: UIScrollView!override func viewDidLoad() {super.viewDidLoad()textField.delegate = self// 注册键盘事件通知NotificationCenter.default.addObserver(self,selector: #selector(keyboardWillShow),name: UIResponder.keyboardWillShowNotification,object: nil)NotificationCenter.default.addObserver(self,selector: #selector(keyboardWillHide),name: UIResponder.keyboardWillHideNotification,object: nil)}deinit {NotificationCenter.default.removeObserver(self)}@objc func keyboardWillShow(_ notification: Notification) {if let keyboardFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect {// 计算键盘顶部在视图中的位置let keyboardTop = view.bounds.height - keyboardFrame.height// 计算文本框底部在视图中的位置let textFieldBottom = textField.convert(textField.bounds, to: view).maxY// 如果文本框被键盘遮挡，调整滚动视图if textFieldBottom > keyboardTop {let offset = textFieldBottom - keyboardTop + 20 // 留出一些空间scrollView.setContentOffset(CGPoint(x: 0, y: offset), animated: true)}}}@objc func keyboardWillHide(_ notification: Notification) {// 恢复滚动视图位置scrollView.setContentOffset(.zero, animated: true)}// 实现 UITextFieldDelegate 方法，处理键盘收起func textFieldShouldReturn(_ textField: UITextField) -> Bool {textField.resignFirstResponder()return true}
}

// 1. 确保视图启用了用户交互
view.isUserInteractionEnabled = true// 2. 确保视图可见且透明度不为 0
view.isHidden = false
view.alpha = 1.0// 3. 检查视图层次结构，确保视图没有被其他视图覆盖
// 使用调试工具（如视图调试器）检查视图层次// 4. 检查手势识别器设置
// 如果手势识别器不需要，移除它
view.gestureRecognizers?.removeAll()// 5. 检查响应链
// 打印响应链，检查事件传递路径
func printResponderChain(for responder: UIResponder?) {var currentResponder = respondervar chain = [UIResponder]()while let responder = currentResponder {chain.append(responder)currentResponder = responder.next}print("响应链:")for (index, responder) in chain.enumerated() {print("\(index). \(type(of: responder))")}
}// 调用示例
printResponderChain(for: view)

// 1. 阻止手势识别器与目标视图同时响应
// 使用手势识别器的 delegate 方法
class ViewController: UIViewController, UIGestureRecognizerDelegate {override func viewDidLoad() {super.viewDidLoad()let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))tapGesture.delegate = selfview.addGestureRecognizer(tapGesture)}func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {// 只在特定条件下接收触摸事件if touch.view is UIButton {return false // 不处理按钮上的触摸事件}return true}@objc func handleTap() {// 处理点击事件}
}// 2. 使用 require(toFail:) 方法设置手势识别器依赖关系
let panGesture = UIPanGestureRecognizer(target: self, action: #selector(handlePan))
let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))// 只有当点击手势识别失败时，才尝试识别滑动手势
panGesture.require(toFail: tapGesture)view.addGestureRecognizer(panGesture)
view.addGestureRecognizer(tapGesture)// 3. 重写 hitTest 方法，精确控制事件接收
override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {let hitView = super.hitTest(point, with: event)// 只允许特定子视图接收事件if hitView is MyCustomView {return hitView}return nil
}

// 1. 使用 require(toFail:) 方法解决手势冲突
let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))
let doubleTapGesture = UITapGestureRecognizer(target: self, action: #selector(handleDoubleTap))// 设置双击手势需要先失败，才能识别单击手势
tapGesture.require(toFail: doubleTapGesture)// 设置双击手势需要点击两次
doubleTapGesture.numberOfTapsRequired = 2view.addGestureRecognizer(tapGesture)
view.addGestureRecognizer(doubleTapGesture)// 2. 使用手势识别器的 delegate 方法解决冲突
class ViewController: UIViewController, UIGestureRecognizerDelegate {override func viewDidLoad() {super.viewDidLoad()let panGesture = UIPanGestureRecognizer(target: self, action: #selector(handlePan))let swipeGesture = UISwipeGestureRecognizer(target: self, action: #selector(handleSwipe))panGesture.delegate = selfswipeGesture.delegate = selfview.addGestureRecognizer(panGesture)view.addGestureRecognizer(swipeGesture)}// 允许同时识别多个手势func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {return true}@objc func handlePan() {// 处理滑动手势}@objc func handleSwipe() {// 处理轻扫手势}
}// 3. 自定义手势识别器
class CustomGestureRecognizer: UIGestureRecognizer {override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesBegan(touches, with: event)// 自定义触摸开始逻辑if touches.count != 1 {state = .failedreturn}// 记录初始位置startLocation = touches.first?.location(in: view)}override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesMoved(touches, with: event)// 自定义触摸移动逻辑if let touch = touches.first, let startLocation = startLocation {let currentLocation = touch.location(in: view)let distance = sqrt(pow(currentLocation.x - startLocation.x, 2) +pow(currentLocation.y - startLocation.y, 2))if distance > minimumDistance {state = .began}}}override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent) {super.touchesEnded(touches, with: event)// 自定义触摸结束逻辑if state == .began {state = .ended} else {state = .failed}}override func reset() {super.reset()// 重置状态startLocation = nil}private var startLocation: CGPoint?private let minimumDistance: CGFloat = 10.0
}

// 1. 优化 Hit-Testing 性能
// 减少视图层次深度
let containerView = UIView()
view.addSubview(containerView)// 避免不必要的视图
let label = UILabel()
containerView.addSubview(label)// 而不是
let unnecessaryContainer = UIView()
view.addSubview(unnecessaryContainer)
let anotherContainer = UIView()
unnecessaryContainer.addSubview(anotherContainer)
label = UILabel()
anotherContainer.addSubview(label)// 2. 避免在主线程执行耗时操作
@objc func handleButtonTap() {// 不良实践：在主线程执行耗时操作// performHeavyCalculation()// 优化实践：在后台线程执行耗时操作DispatchQueue.global().async {self.performHeavyCalculation()// 在主线程更新 UIDispatchQueue.main.async {self.updateUI()}}
}// 3. 减少手势识别器数量
// 只在必要的视图上添加手势识别器
let gesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))
specificView.addGestureRecognizer(gesture)// 而不是在整个视图上添加
// view.addGestureRecognizer(gesture)// 4. 避免频繁的视图重绘
// 使用 CADisplayLink 或 Timer 限制重绘频率
class CustomView: UIView {private var displayLink: CADisplayLink?private var needsUpdate = falseoverride init(frame: CGRect) {super.init(frame: frame)setupDisplayLink()}required init?(coder: NSCoder) {super.init(coder: coder)setupDisplayLink()}private func setupDisplayLink() {displayLink = CADisplayLink(target: self, selector: #selector(updateIfNeeded))displayLink?.add(to: .main, forMode: .common)}@objc private func updateIfNeeded() {if needsUpdate {setNeedsDisplay()needsUpdate = false}}func updateContent() {needsUpdate = true}deinit {displayLink?.invalidate()