检测 UIScrollView 页面变化

Question

当用户在启用分页的 UIScrollView 中更改页面时，有没有办法检测或获取通知？

Answer 1

使用它来检测当前正在显示的页面并对页面更改执行一些操作：

- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
    static NSInteger previousPage = 0;
    CGFloat pageWidth = scrollView.frame.size.width;
    float fractionalPage = scrollView.contentOffset.x / pageWidth;
    NSInteger page = lround(fractionalPage);
    if (previousPage != page) {
        // Page has changed, do your thing!
        // ...
        // Finally, update previous page
        previousPage = page;
    }
}

如果您可以接受仅在滚动完全停止后对页面更改做出反应，那么最好在 scrollViewDidEndDecelerating: 委托方法而不是 scrollViewDidScroll: 方法。

Answer 2

在启用分页的滚动视图中，您可以使用 scrollViewDidEndDecelerating 了解视图何时固定在页面上（可能是同一页面）。

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

scrollViewDidScroll 在每次移动时都会被调用。在分页上下文中，启用视图可用于查找何时滚动到足以移动到下一页（如果在该点停止拖动）。

Answer 3

将 UIScrollViewDelegate 的两个方法结合起来怎么样？

在scrollViewDidEndDragging(_:willDecelerate:)中，如果它立即停止，我们进行页面计算；如果它正在减速，我们放开它，它会被 scrollViewDidEndDecelerating(_:) 捕获。

该代码使用 XCode 版本 7.1.1、Swift 版本 2.1 进行测试

class ViewController: UIViewController, UIScrollViewDelegate {

  // MARK: UIScrollViewDelegate
  func scrollViewDidEndDragging(scrollView: UIScrollView, willDecelerate decelerate: Bool) {
    if decelerate == false {
        let currentPage = scrollView.currentPage
        // Do something with your page update
        print("scrollViewDidEndDragging: \(currentPage)")
    }
  }

  func scrollViewDidEndDecelerating(scrollView: UIScrollView) {
    let currentPage = scrollView.currentPage
    // Do something with your page update
    print("scrollViewDidEndDecelerating: \(currentPage)")
  }

}

extension UIScrollView {
   var currentPage: Int {
      return Int((self.contentOffset.x+ (0.5*self.frame.size.width))/self.frame.width)+1
   }
}

Answer 4

谷歌上关于页面检测的第一个结果，所以我必须用我认为更好的解决方案来回答这个问题。 （即使这个问题是在两年半前提出的。）

我不想仅仅为了跟踪页码而调用 scrollViewDidScroll 。对于这么简单的事情来说，这有点过分了。
使用 scrollViewDidEndDecelerating 确实有效，并在页面更改时停止但是（这是一个很大的但是），如果用户在屏幕上滑动两次的速度比正常 scrollViewDidEndDecelerating 快一点 只会被调用一次。您可以轻松地从第 1 页转到第 3 页，而无需处理第 2 页。

这为我彻底解决了这个问题：

- (void)scrollViewWillBeginDecelerating:(UIScrollView *)scrollView
{
    scrollView.userInteractionEnabled = NO;
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
    //Run your code on the current page
    scrollView.userInteractionEnabled = YES;
}

这样用户一次只能滑动一页，而不会出现上述风险。

Answer 5

Swift 4

我发现最好的方法是使用 scrollViewWillEndDragging(_:withVelocity:targetContentOffset:)。它可以让您预测手指离开屏幕后是否会发生寻呼。此示例用于水平分页。

请记住将 scrollView.delegate 分配给采用 UIScrollViewDelegate 并实现此方法的对象。

var previousPageXOffset: CGFloat = 0.0

func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {

    let targetOffset = targetContentOffset.pointee

    if targetOffset.x == previousPageXOffset {
        // page will not change
    } else if targetOffset.x < previousPageXOffset {
        // scroll view will page left
    } else if targetOffset.x > previousPageXOffset {
        // scroll view will page right
    }

    previousPageXOffset = targetOffset.x
    // If you want to track the index of the page you are on just just divide the previousPageXOffset by the scrollView width.
    // let index = Int(previousPageXOffset / scrollView.frame.width)


}

Answer 6

实现UIScrollView的委托。 这个方法就是您正在寻找的。

- (void)scrollViewDidScroll:(UIScrollView *)scrollView

Answer 7

这是针对此问题的快速解决方案。

在要实现代码的类中创建两个属性 currentPage 和 previousPage 并将它们初始化为 0。

现在从scrollViewDidEndDragging(:willDecelerate:) 更新 currentPage
和scrollViewDidEndDecelerating(:scrollView:)。

然后在scrollViewDidEndScrollingAnimation(_:scrollView:)中更新previousPage

    //Class Properties
    var currentPage = 0
    var previousPage = 0

func scrollViewDidEndDragging(scrollView: UIScrollView, willDecelerate decelerate: Bool) {
        updatePage(scrollView)
        return
    }

 func scrollViewDidEndDecelerating(scrollView: UIScrollView){
        updatePage(scrollView)
        return
    }


 func updatePage(scrollView: UIScrollView) {
        let pageWidth:CGFloat = scrollView.frame.width
        let current:CGFloat = floor((scrollView.contentOffset.x-pageWidth/2)/pageWidth)+1
        currentPage = Int(current)

        if currentPage == 0 {
              // DO SOMETHING
        }
        else if currentPage == 1{
              // DO SOMETHING

        }
    }

func scrollViewDidEndScrollingAnimation(scrollView: UIScrollView) {
     if previousPage != currentPage {
          previousPage = currentPage
          if currentPage == 0 {
              //DO SOMETHING
             }else if currentPage == 1 {
               // DO SOMETHING
           }
       }
   }

Answer 8

var scrollViewPage = 0
override func viewDidLoad() {
    super.viewDidLoad()
    scrollViewPage = scrollView.currentPage
}

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    if scrollViewPage != scrollView.currentPage {
        scrollViewPage = scrollView.currentPage
        // Do something with your page update
        print("scrollViewDidEndDecelerating: \(scrollViewPage)")
    }
}

并使用扩展名

extension UIScrollView {
    var currentPage: Int {
        return Int((self.contentOffset.x + (0.5 * self.frame.size.width)) / 
        self.frame.width) + 1
    }
}

Answer 9

2019 年剪切和粘贴

做到这一点并不容易：

var quantumPage: Int = -100 {   // the UNIQUELY LANDED ON, NEVER REPEATING page
    didSet {
        print(">>>>>> QUANTUM PAGE IS \(quantumPage)")
        pageHasActuallyChanged() // your function
    }
}

private var possibleQuantumPage: Int = -100 {
    didSet {
        if oldValue != possibleQuantumPage {
            quantumPage = possibleQuantumPage
        }
    }
}

public func scrollViewDidEndDragging(
                    _ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
    if decelerate == false {
        possibleQuantumPage = currentPageEvenIfInBetween
    }
}

public func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    possibleQuantumPage = currentPageEvenIfInBetween
}

var currentPageEvenIfInBetween: Int {
   return Int((self.contentOffset.x + (0.5 * self.frame.width)) / self.frame.width)
}

效果完美。

pageHasActuallyChanged仅在用户以人类认为的“更改页面”方式更改页面时被调用。

请注意：启动很棘手：

这很难在启动时初始化，并且取决于您如何使用分页系统。

在任何分页系统中，您很可能会遇到类似“scrollToViewAtIndex...”的内容，

open func scrollToViewAtIndexForBringup(_ index: Int) {
    if index > -1 && index < childViews.count {
        
        let w = self.frame.size.width
        let h = self.frame.size.height
        
        let frame = CGRect(x: CGFloat(index)*w, y: 0, width: w, height: h)
        scrollRectToVisible(frame, animated: false) // NOTE THE FALSE
        
        // AND IMPORTANTLY:
        possibleQuantumPage = currentPageEvenIfInBetween
    }
}

因此，如果用户在第 17 页打开“书”，则在您的 boss 类中，您将调用该函数以将其设置为“17”带来。

在这样的示例中，您只需记住必须在任何此类启动功能；没有真正通用的方法来处理起始情况。

毕竟，例如，您可能想要“快速滚动”到启动页面，并且谁知道这在QuantumPage情况下“意味着”什么。因此，请务必根据您的情况在启动过程中仔细初始化您的量子页面系统。

无论如何，只需复制并粘贴顶部的五个函数即可获得完美的量子分页。

Answer 10

对于斯威夫特

static var previousPage: Int = 0
func scrollViewDidScroll(_ scrollView: UIScrollView){
    let pageWidth: CGFloat = scrollView.frame.width
    let fractionalPage: CGFloat = scrollView.contentOffset.x / pageWidth
    let page = lround(Double(fractionalPage))
    if page != previousPage{
        print(page)
        // page changed
    }
}