Wie kann ich die debounce-Methode nennen?

Swift 3-version

1. Basic-debounce-Funktion

func debounce(interval: Int, queue: DispatchQueue, action: @escaping (() -> Void)) -> () -> Void {
    var lastFireTime = DispatchTime.now()
    let dispatchDelay = DispatchTimeInterval.milliseconds(interval)

    return {
        lastFireTime = DispatchTime.now()
        let dispatchTime: DispatchTime = DispatchTime.now() + dispatchDelay

        queue.asyncAfter(deadline: dispatchTime) {
            let when: DispatchTime = lastFireTime + dispatchDelay
            let now = DispatchTime.now()
            if now.rawValue >= when.rawValue {
                action()
            }
        }
    }
}

2. Parametrisierte debounce-Funktion

Manchmal ist es nützlich zu sein, haben die debounce-Funktion ein parameter.

typealias Debounce<T> = (_ : T) -> Void

func debounce<T>(interval: Int, queue: DispatchQueue, action: @escaping Debounce<T>) -> Debounce<T> {
    var lastFireTime = DispatchTime.now()
    let dispatchDelay = DispatchTimeInterval.milliseconds(interval)

    return { param in
        lastFireTime = DispatchTime.now()
        let dispatchTime: DispatchTime = DispatchTime.now() + dispatchDelay

        queue.asyncAfter(deadline: dispatchTime) {
            let when: DispatchTime = lastFireTime + dispatchDelay
            let now = DispatchTime.now()

            if now.rawValue >= when.rawValue {
                action(param)
            }
        }
    }
}

3. Beispiel

In dem folgenden Beispiel können Sie sehen, wie die entprellung funktioniert, mit einem string-parameter zu identifizieren, die Anrufe.

let debouncedFunction = debounce(interval: 200, queue: DispatchQueue.main, action: { (identifier: String) in
    print("called: \(identifier)")
})

DispatchQueue.global(qos: .background).async {
    debouncedFunction("1")
    usleep(100 * 1000)
    debouncedFunction("2")
    usleep(100 * 1000)
    debouncedFunction("3")
    usleep(100 * 1000)
    debouncedFunction("4")
    usleep(300 * 1000) //waiting a bit longer than the interval
    debouncedFunction("5")
    usleep(100 * 1000)
    debouncedFunction("6")
    usleep(100 * 1000)
    debouncedFunction("7")
    usleep(300 * 1000) //waiting a bit longer than the interval
    debouncedFunction("8")
    usleep(100 * 1000)
    debouncedFunction("9")
    usleep(100 * 1000)
    debouncedFunction("10")
    usleep(100 * 1000)
    debouncedFunction("11")
    usleep(100 * 1000)
    debouncedFunction("12")
}

Hinweis: Die usleep() Funktion ist nur für demo-Zwecke und ist vielleicht nicht die eleganteste Lösung für eine echte app.

Ergebnis

Bekommen Sie immer einen Rückruf, wenn es ein Intervall von mindestens 200 MS seit dem letzten Aufruf.

genannt: 4

genannt: 7

genannt: 12

Erstellen Sie zuerst einen Debouncer generische Klasse:

//
// Debouncer.swift
//
// Created by Frédéric Adda

import UIKit
import Foundation

class Debouncer {

    //MARK: - Properties
    private let queue = DispatchQueue.main
    private var workItem = DispatchWorkItem(block: {})
    private var interval: TimeInterval

    //MARK: - Initializer
    init(seconds: TimeInterval) {
        self.interval = seconds
    }

    //MARK: - Debouncing function
    func debounce(action: @escaping (() -> Void)) {
        workItem.cancel()
        workItem = DispatchWorkItem(block: { action() })
        queue.asyncAfter(deadline: .now() + interval, execute: workItem)
    }
}

Dann erstellen Sie eine Unterklasse von UISearchBar, verwendet die debounce-Mechanismus:

//
// DebounceSearchBar.swift
//
// Created by Frédéric ADDA on 28/06/2018.
//

import UIKit

///Subclass of UISearchBar with a debouncer on text edit
class DebounceSearchBar: UISearchBar, UISearchBarDelegate {

    //MARK: - Properties

    ///Debounce engine
    private var debouncer: Debouncer?

    ///Debounce interval
    var debounceInterval: TimeInterval = 0 {
        didSet {
            guard debounceInterval > 0 else {
                self.debouncer = nil
                return
            }
            self.debouncer = Debouncer(seconds: debounceInterval)
        }
    }

    ///Event received when the search textField began editing
    var onSearchTextDidBeginEditing: (() -> Void)?

    ///Event received when the search textField content changes
    var onSearchTextUpdate: ((String) -> Void)?

    ///Event received when the search button is clicked
    var onSearchClicked: (() -> Void)?

    ///Event received when cancel is pressed
    var onCancel: (() -> Void)?

    //MARK: - Initializers
    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        delegate = self
    }

    override init(frame: CGRect) {
        super.init(frame: frame)
        delegate = self
    }

    override func awakeFromNib() {
        super.awakeFromNib()
        delegate = self
    }

    //MARK: - UISearchBarDelegate
    func searchBarCancelButtonClicked(_ searchBar: UISearchBar) {
        onCancel?()
    }

    func searchBarSearchButtonClicked(_ searchBar: UISearchBar) {
        onSearchClicked?()
    }

    func searchBarTextDidBeginEditing(_ searchBar: UISearchBar) {
        onSearchTextDidBeginEditing?()
    }

    func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
        guard let debouncer = self.debouncer else {
            onSearchTextUpdate?(searchText)
            return
        }
        debouncer.debounce {
            DispatchQueue.main.async {
                self.onSearchTextUpdate?(self.text ?? "")
            }
        }
    }
}

Beachten Sie, dass diese Klasse als UISearchBarDelegate. Maßnahmen verabschiedet werden, um diese Klasse als Verschlüsse.

Schließlich können Sie es verwenden, etwa so:

class MyViewController: UIViewController {

    //Create the searchBar as a DebounceSearchBar
    //in code or as an IBOutlet
    private var searchBar: DebounceSearchBar?


    override func viewDidLoad() {
        super.viewDidLoad()

        self.searchBar = createSearchBar()
    }

    private func createSearchBar() -> DebounceSearchBar {
        let searchFrame = CGRect(x: 0, y: 0, width: 375, height: 44)
        let searchBar = DebounceSearchBar(frame: searchFrame)
        searchBar.debounceInterval = 0.5
        searchBar.onSearchTextUpdate = { [weak self] searchText in
            //call a function to look for contacts, like:
            //searchContacts(with: searchText)
        }
        searchBar.placeholder = "Enter name or email"
        return searchBar
    }
}

Beachten Sie, dass in diesem Fall die DebounceSearchBar ist bereits die Suchleiste delegieren. Sollten Sie NICHT Satz dieses UIViewController-Unterklasse, da die Suchleiste zu delegieren! Noch verwenden delegieren von Funktionen.
Verwenden Sie die mitgelieferten Verschlüsse statt!

Anderen debounce-Implementierung über die Klasse, die Sie nützlich finden können:
https://github.com/webadnan/swift-debouncer

Die Allgemeine Lösung der Frage, und sich in einige der Antworten, hat sich ein Logik-Fehler, die Probleme verursacht, mit kurzen debounce-Schwellenwerte.

Beginnend mit der vorgesehenen Umsetzung:

typealias Debounce<T> = (T) -> Void

func debounce<T>(interval: Int, queue: DispatchQueue, action: @escaping (T) -> Void) -> Debounce<T> {
    var lastFireTime = DispatchTime.now()
    let dispatchDelay = DispatchTimeInterval.milliseconds(interval)

    return { param in
        lastFireTime = DispatchTime.now()
        let dispatchTime: DispatchTime = DispatchTime.now() + dispatchDelay

        queue.asyncAfter(deadline: dispatchTime) {
            let when: DispatchTime = lastFireTime + dispatchDelay
            let now = DispatchTime.now()

            if now.rawValue >= when.rawValue {
                action(param)
            }
        }
    }
}

Prüfung mit einem Intervall von 30 Millisekunden haben, erstellen wir ein relativ triviales Beispiel, das die Schwäche.

let oldDebouncerDebouncedFunction = debounce(interval: 30, queue: .main, action: exampleFunction)

DispatchQueue.global(qos: .background).async {

    oldDebouncerDebouncedFunction("1")
    oldDebouncerDebouncedFunction("2")
    sleep(.seconds(2))
    oldDebouncerDebouncedFunction("3")
}

Diese Drucke

genannt: 1

genannt: 2

genannt: 3

Dies ist eindeutig falsch, da der erste Aufruf sollte entprellten. Mit einem längeren debounce-Schwelle (etwa 300 Millisekunden) wird das problem lösen. Die Wurzel des Problems ist eine falsche Erwartung, dass der Wert von DispatchTime.now() wird gleich die deadline übergeben asyncAfter(deadline: DispatchTime). Die Absicht der Vergleich now.rawValue >= when.rawValue ist, um tatsächlich vergleichen die erwarteten Termin für die "letzten" Frist. Mit kleinen debounce-Schwellenwerte, die Latenz der asyncAfter wird zu einem sehr wichtigen problem zu denken.

Es ist einfach zu beheben, aber, und der code kann gemacht werden präziser oben drauf. Durch die sorgfältige Auswahl, wenn Sie anrufen .now() und Sicherstellung der Vergleich der tatsächlichen Stichtag mit dem zuletzt geplanten Termin, kam ich auf diese Lösung. Was ist richtig für alle Werte von threshold. Achten Sie besonders auf #1 und #2, da Sie die gleiche syntaktisch, aber wird anders sein, wenn mehrere Anrufe gemacht, bevor die Arbeit ausgelöst wird.

typealias DebouncedFunction<T> = (T) -> Void

func makeDebouncedFunction<T>(threshold: DispatchTimeInterval = .milliseconds(30), queue: DispatchQueue = .main, action: @escaping (T) -> Void) -> DebouncedFunction<T> {

    //Debounced function's state, initial value doesn't matter
    //By declaring it outside of the returned function, it becomes state that persists across
    //calls to the returned function
    var lastCallTime: DispatchTime = .distantFuture

    return { param in

        lastCallTime = .now()
        let scheduledDeadline = lastCallTime + threshold //1

        queue.asyncAfter(deadline: scheduledDeadline) {
            let latestDeadline = lastCallTime + threshold //2

            //If there have been no other calls, these will be equal
            if scheduledDeadline == latestDeadline {
                action(param)
            }
        }
    }
}

Dienstprogramme

func exampleFunction(identifier: String) {
    print("called: \(identifier)")
}

func sleep(_ dispatchTimeInterval: DispatchTimeInterval) {
    switch dispatchTimeInterval {
    case .seconds(let seconds):
        Foundation.sleep(UInt32(seconds))
    case .milliseconds(let milliseconds):
        usleep(useconds_t(milliseconds * 1000))
    case .microseconds(let microseconds):
        usleep(useconds_t(microseconds))
    case .nanoseconds(let nanoseconds):
        let (sec, nsec) = nanoseconds.quotientAndRemainder(dividingBy: 1_000_000_000)
        var timeSpec = timespec(tv_sec: sec, tv_nsec: nsec)
        withUnsafePointer(to: &timeSpec) {
            _ = nanosleep($0, nil)
        }
    case .never:
        return
    }
}

Ich hoffe, diese Antwort hilft jemand anderes hat festgestellt unerwartetes Verhalten mit der Funktion currying Lösung.

Hier ist eine option für diejenigen, die nicht wollen, erstellen von Klassen/extensions:

Irgendwo in deinem code:

var debounce_timer:Timer?

Und in Orten, die Sie wollen, um die debounce:

debounce_timer?.invalidate()
debounce_timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: false) { _ in 
    print ("Debounce this...") 
}