如何等待给定时间并仅执行最后一次函数调用

Question

假设我有一个名为Person 的类，其中包含firstName 和lastName 之类的变量。我正在使用响应式Cocoa 框架来监听这些变量的变化，但假设我只使用内置的 KVO 监听，例如 didSet{}。所以假设我有这个代码：

let firstName:String { didSet{ self.nameDidChange() }}
let lastName: String { didSet{ self.nameDidChange() }}

func nameDidChange(){ print("New name:", firstName, lastName}

每次我更改名字或姓氏时，它都会自动调用函数nameDidChange。 我想知道的是，当我同时更改firstName 和lastName 时，这里是否有任何聪明的举措来防止nameDidChange 函数被连续调用两次。

假设firstName 中的值是"Anders" 和lastName 是"Andersson"，那么我运行这段代码：

firstName = "Borat"
lastName = "Boratsson"

nameDidChange 将在这里调用两次。它将首先打印出"New name: Borat Andersson"，然后是"New name: Borat Boratsson"。

在我的简单想法中，我想我可以创建一个名为 nameIsChanging() 之类的函数，在任何 didSet 被调用时调用它，并启动一个 0.1 秒的计时器，然后 调用nameDidChange()，但是这两个didSets 也会调用nameIsChanging，所以定时器会走两次，两次都触发。为了解决这个问题，我可以保留一个“全局”Timer，并使其自身失效并重新开始计数或类似的东西，但我越想解决方案，它们就越难看。这里有什么“最佳实践”吗？

Answer 1

我认为你在正确的轨道上。我认为您只需要延迟对名称更改的调用，直到用户“停止”输入。

类似这样的：

var timer = Timer()

var firstName: String = "Clint" {
    didSet {
        timer.invalidate()
        timer = Timer.scheduledTimer(withTimeInterval: 0.2, repeats: false, block: { _ in
            self.nameDidChange()
        })
    }
}

var secondName: String = "Eastwood" {
    didSet {
        timer.invalidate()
        timer = Timer.scheduledTimer(withTimeInterval: 0.2, repeats: false, block: { _ in
            self.nameDidChange()
        })
    }
}

func nameDidChange() {
    print(firstName + secondName)
}

每次更改第一个或第二个名称时，它都会停止计时器并再等待 0.2 秒，直到它提交名称更改。

编辑

阅读 Adam Venturella 的评论后，我意识到这确实是一种去抖动技术。如果您想了解更多有关该概念的信息，请在 Google 上搜索该概念。

这里有一个简单的 Playground 来说明这个概念：

import UIKit
import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution = true

var timer: Timer? = nil

func nameDidChange() {
    print("changed")
}

func debounce(seconds: TimeInterval, function: @escaping () -> Swift.Void ) {
    timer?.invalidate()
    timer = Timer.scheduledTimer(withTimeInterval: seconds, repeats: false, block: { _ in
        function()
    })
}

debounce(seconds: 0.2) { nameDidChange() }
debounce(seconds: 0.2) { nameDidChange() }
debounce(seconds: 0.2) { nameDidChange() }
debounce(seconds: 0.2) { nameDidChange() }
debounce(seconds: 0.2) { nameDidChange() }
debounce(seconds: 0.2) { nameDidChange() }

输出：

changed

nameDidChange 函数只执行了一次。

Answer 2

不确定我是否正确理解了您的问题，但您可以尝试使用Date 来查看它们何时被解雇，而不是计时器。另请注意，.timeIntervalSince1970 返回自 1970 年以来的秒数，因此我将其乘以 100 以获得更好的精度。

var firstName:String! { didSet{ self.nameDidChange() }}
var lastName: String! { didSet{ self.nameDidChange() }}

var currentDate: UInt64 = UInt64((Date().timeIntervalSince1970 * 100)) - 100

func nameDidChange(){
    let now = UInt64(Date().timeIntervalSince1970 * 100)
    //You can add a higher tolerance here if you wish
    if (now == currentDate) {
        print("firing in succession")
    } else {
        print("there was a delay between the two calls")
    }
    currentDate = now
}

编辑：虽然这不是在最后一次调用而是在第一次调用时运行，但也许这可能有助于/激发一些想法

Answer 3

合并对nameDidChange() 的调用的一种简单方法是通过DispatchQueue.main.async 调用它，除非这样的调用已经挂起。

class MyObject {
    var firstName: String = "" { didSet { self.scheduleNameDidChange() } }
    var lastName: String = "" { didSet { self.scheduleNameDidChange() } }

    private func scheduleNameDidChange() {
        if nameDidChangeIsPending { return }
        nameDidChangeIsPending = true
        RunLoop.main.perform { self.nameDidChange() }
    }

    private func nameDidChange() {
        nameDidChangeIsPending = false
        print("New name:", firstName, lastName)
    }

    private var nameDidChangeIsPending = false
}

如果单个 UI 事件（例如触摸）导致 firstName 和 lastName 发生多次更改，则 nameDidChange() 将仅被调用一次。