Jak uzyskać kierunek pionowy UIScrollView w języku Swift?

Odpowiedź Victora jest świetna, ale jest dość droga, ponieważ zawsze porównujesz i przechowujesz wartości. Jeśli twoim celem jest natychmiastowe określenie kierunku przewijania bez kosztownych obliczeń, spróbuj tego za pomocą Swift :

func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
    let translation = scrollView.panGestureRecognizer.translation(in: scrollView.superview)
    if translation.y > 0 {
        // swipes from top to bottom of screen -> down
    } else {
        // swipes from bottom to top of screen -> up
    }
}

Użyłem odpowiedzi Victora z drobną poprawką podczas przewijania końca lub początku przewijania, a następnie uzyskiwania efektu odbicia. Dodałem ograniczenie obliczając (scrollView.contentSize.wysokość-scrollView.rama.wysokość), a następnie ograniczenie widoku przewijania.contentOffset.zakres y ma być większy niż 0 lub mniejszy niż (scrollView.contentSize.wysokość-scrollView.rama.wysokość), nie ma żadnych zmian podczas odbijania.

 //code

    if(self.lastContentOffset > scrollView.contentOffset.y) &&
    self.lastContentOffset < (scrollView.contentSize.height - scrollView.frame.height) {
        // move up
        buttonAdd.hidden = false
    }
    else if (self.lastContentOffset < scrollView.contentOffset.y 
 && scrollView.contentOffset.y > 0) {
    // move down
        buttonAdd.hidden = true
    }

   // update the new position acquired
   self.lastContentOffset = scrollView.contentOffset.y`

Swift 2-4 z UISwipeGestureRecognizer

Inną opcją jest użycie UISwipeGestureRecognizer, które rozpozna przesunięcie w żądany kierunek (które będzie działać na wszystkich widokach, a nie tylko na UIScrollView

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        let upGs = UISwipeGestureRecognizer(target: self, action: #selector(ViewController.handleSwipes(sender:)))
        let downGs = UISwipeGestureRecognizer(target: self, action: #selector(ViewController.handleSwipes(sender:)))

        upGs.direction = .up
        downGs.direction = .down

        self.view.addGestureRecognizer(upGs)
        self.view.addGestureRecognizer(downGs)
    }

    @objc func handleSwipes(sender:UISwipeGestureRecognizer) {

        if (sender.direction == .up) {
            print("Up")
        }

        if (sender.direction == .down) {
            print("Down")
        }
    }
}

Dla Swift myślę, że najprostszym i najpotężniejszym jest zrobić jak poniżej. Pozwala śledzić, gdy kierunek zmienił się i reagować tylko raz, gdy się zmienił. Dodatkowo możesz zawsze uzyskać dostęp do Właściwości .lastDirection scrolled, jeśli chcesz to sprawdzić w kodzie na dowolnym innym etapie.

enum WMScrollDirection {
    case Up, Down, None
}

class WMScrollView: UIScrollView {
    var lastDirection: WMScrollDirection = .None {
        didSet {
            if oldValue != lastDirection {
                // direction has changed, call your func here
            }
        }
    }

    override var contentOffset: CGPoint {
        willSet {
            if contentOffset.y > newValue.y {
                lastDirection = .Down
            }
            else {
                lastDirection = .Up
            }
        }
    }
}

Powyższe zakłada, że śledzisz tylko przewijanie w górę / w dół. Jest konfigurowalny za pomocą enum. Możesz dodać / zmienić na .left i .right, aby śledzić dowolny kierunek.

Mam nadzieję, że to pomoże ktoś.

Cheers

Mógłbyś zrobić coś takiego:

fileprivate var lastContentOffset: CGPoint = .zero

func checkScrollDirection(_ scrollView: UIScrollView) -> UIScrollViewDirection {
    return lastContentOffset.y > scrollView.contentOffset.y ? .up : .down
}

Oraz z scrollViewDelegate:

func scrollViewDidScroll(_ scrollView: UIScrollView) {
    switch checkScrollDirection(scrollView) {
    case .up:
        // move up
    case .down:
        // move down
    default:
        break
    }

    lastContentOffset = scrollView.contentOffset
}

Odkryłem, że jest to najprostsza i najbardziej elastyczna opcja(działa również dla UICollectionView i UITableView).

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

    switch velocity {
    case _ where velocity.y < 0:
        // swipes from top to bottom of screen -> down
        trackingDirection = .down
    case _ where velocity.y > 0:
        // swipes from bottom to top of screen -> up
        trackingDirection = .up
    default: trackingDirection = .none
    }
}

Gdzie to nie działa, to jeśli istnieje 0 velocity - w takim przypadku nie będziesz miał wyboru, jak tylko użyć rozwiązania przechowywanej właściwości zaakceptowanej odpowiedzi.

Zrobiłem protokół ponownego użycia wskazówek zwoju.

Zadeklaruj te enum i protocol s.

enum ScrollDirection {
    case up, left, down, right, none
}

protocol ScrollDirectionDetectable {
    associatedtype ScrollViewType: UIScrollView
    var scrollView: ScrollViewType { get }
    var scrollDirection: ScrollDirection { get set }
    var lastContentOffset: CGPoint { get set }
}

extension ScrollDirectionDetectable {
    var scrollView: ScrollViewType {
        return self.scrollView
    }
}

Użycie Z ViewController

// Set ScrollDirectionDetectable which has UIScrollViewDelegate
class YourViewController: UIViewController, ScrollDirectionDetectable {
    // any types that inherit UIScrollView can be ScrollViewType
    typealias ScrollViewType = UIScrollView
    var lastContentOffset: CGPoint = .zero
    var scrollDirection: ScrollDirection = .none

}
    extension YourViewController {
        func scrollViewDidScroll(_ scrollView: UIScrollView) {
            // Update ScrollView direction
            if self.lastContentOffset.x > scrollView.contentOffset.x {
                scrollDirection = .left
            } else if self.lastContentOffset.x > scrollView.contentOffset.x {
                scrollDirection = .right
            }

            if self.lastContentOffset.y > scrollView.contentOffset.y {
                scrollDirection = .up
            } else if self.lastContentOffset.y < scrollView.contentOffset.y {
                scrollDirection = .down
            }
            self.lastContentOffset.x = scrollView.contentOffset.x
            self.lastContentOffset.y = scrollView.contentOffset.y
        }
    }

Jeśli chcesz użyć określonego kierunku, po prostu zaktualizuj określone contentOffset, które chcesz.

Dla swift4

public func scrollViewDidScroll(_ scrollView: UIScrollView) {

        if(scrollView.panGestureRecognizer.translation(in: scrollView.superview).y > 0) {
            print("up")
        }
        else {
            print("down")
        }
    }