iOS手势识别完全实战教程

本文还有配套的精品资源，点击获取

简介：手势识别在iOS应用开发中扮演关键角色，是用户交互的基础。"iOS GestureDemo"示例项目旨在帮助开发者理解和应用各种手势识别器。该项目包含"GestureDemo.xcodeproj"工程，演示了如何在应用中集成和自定义包括轻触、滑动、拖拽、捏合、旋转和长按在内的手势识别器。项目中还可能展示了手势识别器的创建、关联、优先级处理以及冲突解决方法。开发者可以通过交互式视图和代码注释学习如何添加、配置和移除手势识别器，以及如何处理代理方法，从而实现响应迅速的用户界面。

1. iOS手势识别概述

iOS平台上的手势识别为用户提供了一种直观且便捷的交互方式。本章节将对iOS中的手势识别进行概括，为后续章节中具体的手势类型应用奠定基础。

1.1 手势识别的定义

手势识别是捕捉用户对屏幕的触摸、滑动、点击等操作，并将其转化为应用程序能够理解的命令的过程。它极大地提高了用户与移动应用之间的互动性，使得操作更加自然、直观。

1.2 手势识别器（UIGestureRecognizer）的角色

UIGestureRecognizer 是iOS中用于处理手势识别的抽象基类。通过继承这个类并实现特定的方法，开发者可以创建自定义手势识别器。而对于常见的手势，如轻触、滑动、拖拽等，iOS提供了相应的子类实现，如 UITapGestureRecognizer 、 UISwipeGestureRecognizer 等。这些预置的手势识别器类简化了手势处理的开发工作。

接下来的章节将详细介绍这些预置的手势识别器在iOS开发中的应用与优化。

2. 轻触手势（UITapGestureRecognizer）应用

2.1 轻触手势的基本使用

轻触手势是最基本也是最简单的手势交互方式，通常用于响应用户的轻触操作。在iOS开发中，UITapGestureRecognizer是用于处理轻触手势的类。开发者可以通过这个类实现对视图的轻触事件的捕获和处理。

2.1.1 轻触手势的创建与识别

要使用UITapGestureRecognizer，首先需要创建一个手势识别器的实例，并将其添加到视图上。以下是一个简单的代码示例：

// 创建一个UITapGestureRecognizer的实例，指定响应的手势数量为1
let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleTap))

// 将手势识别器添加到一个视图上
view.addGestureRecognizer(tapGestureRecognizer)

在上述代码中， handleTap 方法需要被定义以响应轻触手势：

@objc func handleTap() {
    print("轻触手势被触发")
}

通过上述代码，当用户对注册了轻触手势识别器的视图执行轻触操作时， handleTap 方法会被调用，控制台会打印出"轻触手势被触发"。

2.1.2 轻触手势的响应方法

轻触手势识别器提供了两个重要的属性来帮助开发者更好地响应手势： numberOfTapsRequired 和 numberOfTouchesRequired 。 numberOfTapsRequired 属性指定了触发手势所需的轻触次数，而 numberOfTouchesRequired 属性指定了同时触摸的手指数。这两个属性都可以在初始化UITapGestureRecognizer实例时设置。

// 创建一个轻触两次的手势识别器，且需要两个手指同时轻触
let doubleTapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleDoubleTap))
doubleTapGestureRecognizer.numberOfTapsRequired = 2
doubleTapGestureRecognizer.numberOfTouchesRequired = 2
view.addGestureRecognizer(doubleTapGestureRecognizer)

@objc func handleDoubleTap() {
    print("双击手势被触发")
}

在这个示例中，我们创建了一个双击手势识别器，并要求同时有两个手指进行轻触。当这样的操作发生时， handleDoubleTap 方法会被调用，控制台打印出"双击手势被触发"。

2.2 轻触手势的进阶应用

轻触手势的进阶应用涉及到手势的组合使用以及与其他视图事件的结合。这允许开发人员设计更加复杂和流畅的用户交互体验。

2.2.1 多个轻触手势的识别与处理

当视图上同时注册了多个轻触手势识别器时，iOS系统会根据一定的规则来决定哪个手势识别器来响应这次手势。如果手势识别器设置的 numberOfTapsRequired 或 numberOfTouchesRequired 不匹配，则不会响应。在识别冲突的情况下，iOS遵循“先添加者优先”的原则。

let tapGestureRecognizer1 = UITapGestureRecognizer(target: self, action: #selector(handleTap1))
tapGestureRecognizer1.numberOfTapsRequired = 1

let tapGestureRecognizer2 = UITapGestureRecognizer(target: self, action: #selector(handleTap2))
tapGestureRecognizer2.numberOfTapsRequired = 1

// 为了解决多个轻触手势识别器之间的冲突，可以设置优先级
tapGestureRecognizer2requirementLevel = .required

// 将两个手势识别器都添加到同一个视图上
view.addGestureRecognizer(tapGestureRecognizer1)
view.addGestureRecognizer(tapGestureRecognizer2)

在这个例子中，假设有两个轻触手势识别器同时添加到视图上。为了避免冲突，我们为第二个识别器设置了 requirementLevel 属性为 .required ，表明这个识别器需要被优先识别。

2.2.2 轻触手势与视图事件的结合使用

除了直接响应手势事件外，开发者还可以将轻触手势与其他视图事件结合使用，如点击按钮或链接等。这要求在响应手势识别器的方法中添加相应的逻辑。

@objc func handleTap() {
    if isLinkButton压在手势识别器上 {
        openLink(linkURL)
    } else {
        print("非链接区域的轻触手势被触发")
    }
}

在这段代码中，我们检查手势识别器触发时是否位于一个链接按钮上。如果是，就打开链接。如果不是，就简单地打印出一条消息。这种判断在iOS应用中需要通过自定义的逻辑或额外的视图层级管理来实现。

为了更好地展示轻触手势的集成和自定义，接下来我们将详细探讨如何在实际应用中使用这些手势。我们会从手势识别器的集成方法开始，然后转向更高级的自定义实现。

3. 滑动手势（UISwipeGestureRecognizer）应用

滑动手势（UISwipeGestureRecognizer）在iOS中用于识别用户在视图上执行的快速水平移动。它常用于实现诸如切换图片、翻页等功能。本章节将逐步深入探讨UISwipeGestureRecognizer的基本使用和进阶应用，以及如何高效地将它们集成到应用程序中。

3.1 滑动手势的基本使用

3.1.1 滑动手势的创建与识别

滑动手势的创建和识别过程非常直接。通过初始化一个 UISwipeGestureRecognizer 实例并指定滑动方向，然后将这个实例添加到视图上即可。以下是创建和添加滑动手势识别器的基本步骤：

// 创建一个向右滑动手势识别器
let swipeRight = UISwipeGestureRecognizer(target: self, action: #selector(handleSwipe(_:)))
swipeRight.direction = .right
// 将识别器添加到视图上
view.addGestureRecognizer(swipeRight)

在这个代码片段中： - target 属性设置了手势识别器的目标对象，通常是控制器或视图控制器。 - action 属性指定了当手势被识别时调用的方法。 - direction 属性定义了识别的手势方向。

为了完成识别过程，我们还需要实现 handleSwipe 方法来响应手势：

@objc func handleSwipe(_ sender: UISwipeGestureRecognizer) {
    // 根据sender的方向执行相应操作
    if sender.direction == .right {
        print("Detected swipe to the right!")
    }
}

3.1.2 滑动手势的响应方法

响应方法是实际处理手势动作的地方。在 handleSwipe 方法中，我们可以根据滑动方向执行不同的操作。如下图所示，一个简单的响应方法流程：

graph LR
A[用户滑动屏幕] -->|检测到滑动手势| B[识别方向]
B --> C{方向是右吗？}
C -->|是| D[执行操作]
C -->|否| E[结束]
D --> E[等待下一个手势]

实际应用中，响应方法可能需要触发特定的UI更新或业务逻辑处理。在实现响应方法时，可以通过检查 sender.direction 来区分不同的滑动方向并做出相应的响应。

3.2 滑动手势的进阶应用

3.2.1 多个滑动手势的识别与处理

在许多场景中，应用需要同时识别和处理多个滑动手势。例如，在一个图片查看应用中，用户可能希望向左滑动切换到上一张图片，同时也可以向右滑动切换到下一张图片。

实现多个滑动手势的基本原理是为每个方向的滑动添加一个独立的 UISwipeGestureRecognizer 实例。以下是添加两个滑动手势（向左和向右滑动）的代码示例：

let swipeLeft = UISwipeGestureRecognizer(target: self, action: #selector(handleSwipe(_:)))
swipeLeft.direction = .left
view.addGestureRecognizer(swipeLeft)

let swipeRight = UISwipeGestureRecognizer(target: self, action: #selector(handleSwipe(_:)))
swipeRight.direction = .right
view.addGestureRecognizer(swipeRight)

在处理这些手势时，我们需要确定滑动的具体方向来区分不同的行为：

@objc func handleSwipe(_ sender: UISwipeGestureRecognizer) {
    switch sender.direction {
    case .left:
        // 处理向左滑动的逻辑
        print("Detected swipe to the left!")
    case .right:
        // 处理向右滑动的逻辑
        print("Detected swipe to the right!")
    default:
        break
    }
}

3.2.2 滑动手势与视图事件的结合使用

滑动手势可以与视图的其他事件（如点击、长按等）结合使用，提供更为丰富和互动的用户体验。例如，在一个地图应用中，用户可以通过点击选中一个位置，然后通过滑动该位置来调整它。这就需要将滑动手势与视图的其他交互方式相结合。

在Swift中，可以通过禁用或启用视图的交互属性来控制手势与其他事件的结合使用。当启用滑动手势时，应禁用视图的用户交互，以避免手势与视图的其他事件冲突。

// 启用滑动手势
view.isUserInteractionEnabled = true
// 同时禁用视图的其他交互
view.isUserInteractionEnabled = false

接下来的章节将继续探讨如何在应用中集成和自定义手势识别器，以及如何处理手势识别器之间的冲突和优先级问题。

4. 拖拽手势（UIPanGestureRecognizer）应用

4.1 拖拽手势的基本使用

4.1.1 拖拽手势的创建与识别

拖拽手势（ UIPanGestureRecognizer ）是用户在视图上通过拖拽移动手指时所识别的手势。iOS通过 UIPanGestureRecognizer 类来识别并处理拖拽事件。要创建拖拽手势，你需要实例化 UIPanGestureRecognizer 并将其添加到视图上。下面是一个基本的创建与识别拖拽手势的例子：

// 创建一个拖拽手势识别器
let panGesture = UIPanGestureRecognizer(target: self, action: #selector(handlePanGesture(_:)))

// 将手势添加到视图上
view.addGestureRecognizer(panGesture)

在上述代码中， handlePanGesture 是当拖拽手势被触发时调用的方法，你需要在你的视图控制器中实现这个方法。

4.1.2 拖拽手势的响应方法

在响应拖拽手势的方法中，你可以通过 UIPanGestureRecognizer 的属性获取到拖拽的详细信息，例如拖拽开始的位置、当前位置以及拖拽的距离等。以下是如何在 handlePanGesture 方法中处理拖拽手势：

@objc func handlePanGesture(_ gestureRecognizer: UIPanGestureRecognizer) {
    let translation = gestureRecognizer.translation(in: view)
    switch gestureRecognizer.state {
    case .began:
        // 拖拽开始，可以根据需要进行特定操作
    case .changed:
        // 拖拽过程中，可以实时更新视图位置
        let newCenter = CGPoint(x: originalCenter.x + translation.x, y: originalCenter.y + translation.y)
        view.center = newCenter
    case .ended:
        // 拖拽结束，可以设置视图的新位置或者结束拖拽动画
        let finalCenter = CGPoint(x: originalCenter.x + translation.x, y: originalCenter.y + translation.y)
        view.center = finalCenter
    default:
        break
    }
    // 更新手势状态
    gestureRecognizer.setTranslation(CGPoint.zero, in: view)
}

在 handlePanGesture 方法中， translation(in:) 方法用于获取手势在指定视图内的偏移量。你可以使用这个偏移量来更新视图的位置或者实现其他拖拽相关的动画效果。

4.2 拖拽手势的进阶应用

4.2.1 多个拖拽手势的识别与处理

在实际应用中，可能会有多个视图同时响应拖拽手势。这种情况下，需要正确识别和处理这些手势，以避免手势间的冲突。你可以为不同的视图设置不同的拖拽手势识别器，或者在同一个手势识别器中识别多个手指的拖拽动作。

let panGesture = UIPanGestureRecognizer(target: self, action: #selector(handlePanGesture(_:)))

// 允许多点触控拖拽
panGesture.minimumNumberOfTouches = 2

view1.addGestureRecognizer(panGesture)
view2.addGestureRecognizer(panGesture)

在上述代码中，通过设置 minimumNumberOfTouches 属性，可以让手势识别器处理多点触控的拖拽动作。当两个手指同时拖拽时，手势识别器会同时接收到两个触摸点的信息。

4.2.2 拖拽手势与视图事件的结合使用

拖拽手势经常与其他视图事件（例如点击、长按等）结合使用。通过结合使用，可以实现更加丰富和复杂的用户交互体验。例如，你可以实现一个拖拽控件来重排列表项的功能。

// 其他手势识别器代码省略...

// 拖拽手势识别器
let panGesture = UIPanGestureRecognizer(target: self, action: #selector(handlePanGesture(_:)))

// 将手势添加到每个列表项视图上
for item in listItems {
    item.view.addGestureRecognizer(panGesture)
}

func handlePanGesture(_ gestureRecognizer: UIPanGestureRecognizer) {
    // 执行拖拽动作的相关逻辑
    // 与其他手势识别器的事件进行结合判断
    if let longPressGesture = gestureRecognizer.longPressGestureRecognizer {
        switch longPressGesture.state {
        case .began:
            // 在长按手势开始时，执行一些预处理
            break
        default:
            break
        }
    }
    // 继续拖拽手势的处理逻辑
}

在这个例子中，拖拽手势识别器与长按手势识别器（ UILongPressGestureRecognizer ）结合使用，通过检查 longPressGestureRecognizer 的状态，可以决定拖拽时是否执行特定的操作。这种结合使用可以让你在处理拖拽事件时更加灵活。

通过以上内容的讲解，我们不仅了解了拖拽手势的基本使用，也探讨了拖拽手势的进阶应用技巧，如多点触控拖拽以及与其他手势的结合使用。在接下来的章节中，我们将继续深入探讨捏合手势和旋转手势的应用，以及手势识别器的集成和自定义方法。

5. 捏合手势（UIPinchGestureRecognizer）应用

5.1 捏合手势的基本使用

5.1.1 捏合手势的创建与识别

捏合手势（UIPinchGestureRecognizer）是多点触控界面中常见的操作，主要用于放大或缩小图像、文本或其他可缩放对象。在iOS开发中，UIPinchGestureRecognizer提供了简单直接的方式来实现这一功能。

创建捏合手势识别器的基本步骤如下：

1. 初始化手势识别器：

let pinchGestureRecognizer = UIPinchGestureRecognizer(target: self, action: #selector(pinchAction(_:)))

这里，我们使用 UIPinchGestureRecognizer 的构造器来创建一个捏合手势识别器。 target 参数是一个对象，当手势识别器识别到捏合动作时，它会调用这个对象上的 action 方法。在我们的示例中， #selector(pinchAction(_:) 是一个指向我们希望被调用的方法的 selector。

1. 将手势识别器添加到视图中：

self.view.addGestureRecognizer(pinchGestureRecognizer)

通过调用视图对象的 addGestureRecognizer(_:) 方法，我们可以将创建的手势识别器添加到视图中。这样，当用户在该视图上进行捏合操作时，就能被识别器捕获。

5.1.2 捏合手势的响应方法

一旦捏合手势被添加到视图中，对应的响应方法将被触发。在上述代码中，我们设置了 pinchAction(_:) 方法作为响应捏合手势的方法。这个方法应该实现如下：

@objc func pinchAction(_ sender: UIPinchGestureRecognizer) {
    if sender.state == .changed {
        let scale = sender.scale
        let translation = sender.translation(in: self.view)
        // 在这里添加缩放和拖动逻辑
        // scale 的值用于调整元素大小，translation 的值用于调整元素位置
    }
}

在 pinchAction(_:) 方法中，我们首先检查手势识别器的 state 属性。如果手势处于 .changed 状态，表明用户正在改变捏合状态（即正在缩放），此时可以获取到 scale 和 translation 两个重要的属性值。

• scale 属性表示捏合手势相对于初始状态的缩放比例。在捏合开始时，初始值为1.0，当用户手指分开时， scale 值大于1.0，反之则小于1.0。
• translation 属性是用户手势移动后，相对于手势开始时的位移。它是一个 CGVector 类型，包含了x和y两个方向的位移值。

你可以利用这些属性来实现视图的缩放和位移效果。例如，可以将缩放比例应用到视图的 transform 属性，从而改变视图的大小。

5.2 捏合手势的进阶应用

5.2.1 多个捏合手势的识别与处理

当页面上存在多个可缩放对象时，可能需要同时对多个捏合手势进行识别和处理。iOS的手势识别器是设计成可以识别多个手势同时发生的。为了处理这种情况，我们需要对每个可缩放视图分别添加捏合手势识别器，并在相应的响应方法中确定哪个视图被用户操作。

以下是一个示例代码，用于添加多个捏合手势识别器并处理它们：

// 假设我们有两个可缩放视图 view1 和 view2
let pinch1 = UIPinchGestureRecognizer(target: self, action: #selector(handlePinch(sender:)))
let pinch2 = UIPinchGestureRecognizer(target: self, action: #selector(handlePinch(sender:)))

// 将手势识别器添加到各自视图
view1.addGestureRecognizer(pinch1)
view2.addGestureRecognizer(pinch2)

@objc func handlePinch(sender: UIPinchGestureRecognizer) {
    if let view = sender.view {
        // 根据 sender.view 来区分哪个视图触发了手势
        if view == view1 {
            // 处理 view1 的缩放逻辑
        } else if view == view2 {
            // 处理 view2 的缩放逻辑
        }
    }
}

在这段代码中，我们创建了两个捏合手势识别器，并将它们添加到各自的视图中。然后在响应方法 handlePinch(sender:) 中，我们通过 sender.view 来确定哪个视图触发了手势，从而实现对多个视图的独立控制。

5.2.2 捏合手势与视图事件的结合使用

捏合手势不仅可以用于缩放视图，还可以与其他事件相结合，比如与 UIPanGestureRecognizer 结合实现拖拽缩放功能。这种结合使用可以为用户带来更加丰富和直观的交互体验。

以下是一个结合捏合手势和拖拽手势处理视图缩放和移动的示例代码：

// 创建并添加捏合手势识别器
let pinchRecognizer = UIPinchGestureRecognizer(target: self, action: #selector(handlePinch(_:)))
self.view.addGestureRecognizer(pinchRecognizer)

// 创建并添加拖拽手势识别器
let panRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
self.view.addGestureRecognizer(panRecognizer)

@objc func handlePinch(_ sender: UIPinchGestureRecognizer) {
    // 处理缩放逻辑
    if sender.state == .changed {
        let scale = sender.scale
        self.scaleView(view: sender.view!, by: scale)
    }
}

@objc func handlePan(_ sender: UIPanGestureRecognizer) {
    // 处理拖拽逻辑
    if sender.state == .changed {
        let translation = sender.translation(in: self.view)
        self.translateView(view: sender.view!, by: translation)
    }
}

func scaleView(view: UIView, by scale: CGFloat) {
    // 缩放视图
    view.transform = view.transform.scaledBy(x: scale, y: scale)
}

func translateView(view: UIView, by translation: CGPoint) {
    // 移动视图
    view.center = CGPoint(x: view.center.x + translation.x, y: view.center.y + translation.y)
}

在这个例子中，我们为视图添加了两个手势识别器： pinchRecognizer 和 panRecognizer 。它们分别处理缩放和拖拽事件。通过 scaleView 和 translateView 方法，我们可以根据识别器提供的信息调整视图的大小和位置。这样，当用户进行捏合操作时，视图将同时响应缩放和拖拽变化。

结合手势的使用使得交互设计更加灵活和高效，能够更好地满足用户在使用应用时对界面操作的需求。

6. 旋转手势（UIRotationGestureRecognizer）应用

6.1 旋转手势的基本使用

6.1.1 旋转手势的创建与识别

旋转手势（UIRotationGestureRecognizer）是iOS中用来处理用户旋转操作的手势识别器。它通常用于旋转图片、视图等对象。在这一部分，我们首先来了解如何在iOS应用中创建和识别旋转手势。

创建旋转手势识别器的代码如下：

let rotationGesture = UIRotationGestureRecognizer(target: self, action: #selector(handleRotation(_:)))
view.addGestureRecognizer(rotationGesture)

在这段代码中，我们首先创建了一个 UIRotationGestureRecognizer 的实例， target 是需要响应旋转手势的对象， action 是一个指定的方法，该方法将被调用以响应手势。创建后，我们将其添加到对应的视图上，以便识别该视图上的旋转手势。

6.1.2 旋转手势的响应方法

当旋转手势被识别后，应用将调用 handleRotation 方法。以下是一个简单的响应方法示例：

@objc func handleRotation(_ gesture: UIRotationGestureRecognizer) {
    if let viewToRotate = gesture.view {
        let rotation: CGFloat = gesture.rotation
        viewToRotate.transform = viewToRotate.transform.rotated(by: rotation)
        gesture.rotation = 0
    }
}

这段代码中， handleRotation 方法通过 gesture 参数来获取旋转角度。然后使用 rotated(by:) 方法来旋转视图的 transform 属性，从而实现视图的旋转效果。注意，旋转完成后，我们手动将 rotation 属性归零，这是为了防止后续的旋转操作累积之前的旋转角度。

6.2 旋转手势的进阶应用

6.2.1 多个旋转手势的识别与处理

在某些应用中，可能需要同时识别多个旋转手势，例如在一个画布应用中，用户可能希望旋转画布的同时也旋转其中的某个元素。此时，我们需要对每个手势进行独立处理。

下面是一个处理多个旋转手势的示例代码：

var canvasRotationGesture: UIRotationGestureRecognizer?
var elementRotationGesture: UIRotationGestureRecognizer?

override func viewDidLoad() {
    super.viewDidLoad()
    canvasRotationGesture = UIRotationGestureRecognizer(target: self, action: #selector(handleCanvasRotation(_:)))
    elementRotationGesture = UIRotationGestureRecognizer(target: self, action: #selector(handleElementRotation(_:)))
    canvas.addGestureRecognizer(canvasRotationGesture)
    element.addGestureRecognizer(elementRotationGesture)
}

@objc func handleCanvasRotation(_ gesture: UIRotationGestureRecognizer) {
    // 旋转画布的代码逻辑
}

@objc func handleElementRotation(_ gesture: UIRotationGestureRecognizer) {
    // 旋转元素的代码逻辑
}

在此代码中，我们为画布和元素分别创建了两个独立的旋转手势识别器，并将它们添加到对应的视图上。然后为每个手势分别实现了处理方法 handleCanvasRotation 和 handleElementRotation ，分别处理画布和元素的旋转逻辑。

6.2.2 旋转手势与视图事件的结合使用

旋转手势不仅能够独立使用，还可以与其他UI事件结合使用，例如拖拽手势，以实现更复杂的交互效果。以下是一个结合拖拽和旋转手势的示例：

@objc func handlePanAndRotate(_ gesture: UIPanGestureRecognizer) {
    // 处理拖拽逻辑
}

@objc func handleRotate(_ gesture: UIRotationGestureRecognizer) {
    // 处理旋转逻辑
}

在这个场景中，我们假定拖拽手势和旋转手势同时作用于同一个视图。为了准确地处理这两种手势的相互影响，我们可以在手势识别器的 state 属性中进行判断。例如，我们可以检查旋转手势是否在拖拽过程中开始，如果是，则可以调整旋转中心，或者对旋转速度进行一些优化处理。

结合不同手势的使用，能够提供更流畅和直观的用户体验，但同时也增加了代码的复杂度。开发者在设计时需要平衡交互逻辑的复杂性与用户体验的直观性。

7. 长按手势（UILongPressGestureRecognizer）应用

长按手势是用户在界面上持续按压一定时间后，系统识别到的一种交互动作。在iOS开发中，长按手势可用来实现如放大镜效果、菜单弹出等多种交互。让我们深入了解长按手势的基本使用及进阶应用。

7.1 长按手势的基本使用

7.1.1 长按手势的创建与识别

创建一个长按手势很简单，我们只需要实例化 UILongPressGestureRecognizer 并将其添加到目标视图上。以下是一个创建长按手势并添加到视图的代码示例：

let longPressGesture = UILongPressGestureRecognizer(target: self, action: #selector(handleLongPress(gesture:)))
self.view.addGestureRecognizer(longPressGesture)

@objc func handleLongPress(gesture: UILongPressGestureRecognizer) {
    switch gesture.state {
    case .began:
        // 长按手势开始识别时执行的代码
    case .changed:
        // 长按手势状态改变时执行的代码
    case .ended:
        // 长按手势结束时执行的代码
    case .cancelled:
        // 长按手势被取消时执行的代码
    case .failed:
        // 长按手势识别失败时执行的代码
    default:
        break
    }
}

7.1.2 长按手势的响应方法

长按手势可以被识别为几个不同的状态，如开始、改变、结束和取消。根据不同的状态，我们可以对视图进行不同操作：

• 当长按手势开始时，可以初始化一些变量或者暂停其他手势识别。
• 当长按手势状态改变时，可以更新与手势相关的UI或动画效果。
• 长按手势结束时，可能是触发动作的时机，如打开菜单或显示上下文选项。
• 长按手势被取消或失败时，可以清理手势相关的资源。

7.2 长按手势的进阶应用

7.2.1 多个长按手势的识别与处理

当需要在同一个视图上识别多个长按手势时，可以创建多个 UILongPressGestureRecognizer 实例，并分别设置它们。需要注意的是，每个手势识别器需要有独立的处理方法。

let longPressGesture1 = UILongPressGestureRecognizer(target: self, action: #selector(handleLP1))
let longPressGesture2 = UILongPressGestureRecognizer(target: self, action: #selector(handleLP2))
self.view.addGestureRecognizer(longPressGesture1)
self.view.addGestureRecognizer(longPressGesture2)

@objc func handleLP1(gesture: UILongPressGestureRecognizer) {
    // 处理第一个长按手势...
}

@objc func handleLP2(gesture: UILongPressGestureRecognizer) {
    // 处理第二个长按手势...
}

7.2.2 长按手势与视图事件的结合使用

长按手势可以与视图的其他事件如点击、拖动等协同工作，以提供更丰富的用户体验。例如，可以在长按手势识别后，禁用视图的其他交互，以避免手势识别冲突。

以下示例展示了在长按手势开始时禁用视图的点击事件，并在结束时重新启用：

var viewEnabled = true

@objc func handleLongPress(gesture: UILongPressGestureRecognizer) {
    switch gesture.state {
    case .began:
        self.view.isEnabled = false
    case .ended, .cancelled, .failed:
        self.view.isEnabled = viewEnabled
    default:
        break
    }
}

通过合理利用长按手势的识别与处理，可以大幅提升应用的交互质量与用户体验。在第七章的下一节中，我们将进一步探讨长按手势的应用案例，以及如何与其他手势结合使用。

本文还有配套的精品资源，点击获取

简介：手势识别在iOS应用开发中扮演关键角色，是用户交互的基础。"iOS GestureDemo"示例项目旨在帮助开发者理解和应用各种手势识别器。该项目包含"GestureDemo.xcodeproj"工程，演示了如何在应用中集成和自定义包括轻触、滑动、拖拽、捏合、旋转和长按在内的手势识别器。项目中还可能展示了手势识别器的创建、关联、优先级处理以及冲突解决方法。开发者可以通过交互式视图和代码注释学习如何添加、配置和移除手势识别器，以及如何处理代理方法，从而实现响应迅速的用户界面。

本文还有配套的精品资源，点击获取