标签: debouncing

我对c和Raspberry Pi相对较新,我正在尝试简单的程序.我想要的是当按下按钮时printfs一次并且不再打印,直到再次按下按钮,即使按下按钮(类似闩锁).我想可能会添加第二个while循环来解决这个问题,但有时它仍然没有检测到按下按钮.

#include <bcm2835.h>
#include <stdio.h>
#define PIN RPI_GPIO_P1_11

int main()
{
    if(!bcm2835_init())
        return 1;

    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_INPT);

    while(1)
    {
        if(bcm2835_gpio_lev(PIN))
        {
            printf("The button has been pressed\n");
        }

       while(bcm2835_gpio_lev(PIN)){}
    }

    bcm2835_close();
    return 0;
}

我想这里可能有一个名字,但我不知道.所以我的第一个问题是要知道这种技术的名称.

这是一个例子:假设您正在网页上实施实时搜索.每次用户在搜索框中键入内容时,您都会触发新的搜索查询,并尽可能经常更新结果.这是一个愚蠢的事情,因为你会发送比实际需要更多的查询.每2-3个字母发送一次请求或每100毫秒发送一次请求可能就足够了.

因此,一种技术是在键入键后立即执行查询,如果仍有计划但未执行的查询,则取消它们,因为它们现在已经过时了.

现在更具体地说,是否有特定的模式或库来解决Java中的这个问题？

我必须在Swing应用程序中解决问题,并且我使用了ExecutorService,它返回了我可以取消的ScheduledFutures.问题是我必须手动为我想要"缓冲"的每个方法调用创建一个Runnable,并跟踪每个Future以取消它.

我确定我不是第一个实现这样的东西的人,所以某处必须有可重复使用的解决方案？可能是Spring中有注释和代理的东西？

如何消除可以从多个事件中启动的动作？这是一个示例，仅用于演示行为：http : //jsfiddle.net/eXart/2/

<input type="text" id="t">

<div id="x"></div>

<script>
function debounce(fn, delay) {
    var timer = null;
    return function () {
        var context = this, args = arguments;
        clearTimeout(timer);
        timer = setTimeout(function () {
            fn.apply(context, args);
        }, delay);
    };
}

function doStuff(){
    document.getElementById("x").innerHTML +="<br>stuff";
}

    var t = document.getElementById("t");
    t.onchange = debounce(function(){ doStuff() }, 500);
    t.onblur = debounce(function(){ doStuff() }, 500);
</script>

如果您在文本框中输入一些文本并单击退出，您会看到“stuff”出现两次而不是一次，因为每个事件都获得了它自己的去抖动实例。您如何跨事件共享去抖动实例？

LoDash的防抖动接受一个选项maxWait.

来自文档:

[options.maxWait](数字):func允许在调用之前延迟最长时间.

我很困惑,是不是和使用油门一样？有什么不同？

在我们的应用程序中，我们公开了供外部服务使用的回调路由。当我们收到回调时，我们使用客户端/浏览器端的Eventsource和服务器端的抽筋向客户端订阅者发布更新。但是，有时，我们会受到来自此外部服务的回调请求的轰炸，这导致我们向客户端发布了很多更新。在Rails端是否有一种类似于javascript防反跳功能的方法，可以在收到的回调之间等待设置的时间来发布消息？

我们已经在使用sidekiq +线程，因此欢迎使用这些工具的建议。

如果我有一个功能foo。它会在短时间内收到许多呼叫。

function foo(name) {
  console.log(`Hi ${name}, it is now: `, new Date());
}

使用 lodash 延迟连续函数调用（ debounce ）工作正常。

   const debouncedFoo = _.debounce(foo, 1000 );

但是，我的目标是即使超时 ( 1000) 已经过去也不执行整个调用队列，并且只考虑要执行的最后一次调用。

换句话说，如果我debouncedFoo在 900 毫秒内调用了5 次（小于“等待参数”1000 毫秒），我只想foo被执行一次，这是最后一次 (5??) 调用。

阅读 lodash 文档，我知道它debounce被 3 重载了？？参数是选项。我使用了它们，但没有发生预期的行为：

   // first attempt
  const debouncedFoo = _.debounce(foo, 1000, {leading: true} );
  // second attempt
  const debouncedFoo = _.debounce(foo, 1000, {trailing: false} );

我正在学习ReactJS并遇到以下问题.我有一个联系人搜索输入,并希望在用户停止输入后1000ms内处理它.我为此目的使用去抖功能:

import React, { Component}  from 'react';
import ReactDOM  from 'react-dom';
import './index.css';
import {debounce} from 'lodash';

const contacts = [
    {
        id: 1,
        name: 'Darth Vader',
        phoneNumber: '+250966666666',
        image: 'img/darth.gif'
    }, {
        id: 2,
        name: 'Princess Leia',
        phoneNumber: '+250966344466',
        image: 'img/leia.gif'
    }, {
        id: 3,
        name: 'Luke Skywalker',
        phoneNumber: '+250976654433',
        image: 'img/luke.gif'
    }, {
        id: 4,
        name: 'Chewbacca',
        phoneNumber: '+250456784935',
        image: 'img/chewbacca.gif'
    }
];

class Contact extends React.Component {
    render() {
        return (
            <li className="contact">
                <img className="contact-image" src={this.props.image} width="60px" …

剧透；我对 jQuery/Javascript 完全陌生。

我有一个布尔字段CheckMe和一个输入字段textField。

如果textField为空，则CheckMe不应显示，否则应该显示（这意味着如果从非空变为空，CheckMe则应立即再次隐藏）。我想解析一个延迟，比如说 500 毫秒，即CheckMe显示如果text如果不为空并且在最后一次按键 500 毫秒后

我尝试使用此SO 答案中的去抖函数（请参阅下面的实现），但问题是，在空CheckMe500 毫秒后也首先隐藏textField

<script type="text/javascript">
  function debounce(fn, duration) {
  var timer;
  return function(){
    clearTimeout(timer);
    timer = setTimeout(fn, duration);
  }
}

$(document).ready(function () {
    const textField= $("#textField");
    const CheckMe= $("#CheckMe");
    CheckMe.hide();

    textField.on("input", debounce(()=> {
      if (textField.val()) {
        CheckMe.show();
      } else {
        CheckMe.hide();
      }
    },500));
});
</script>

但当checkMe我清除时，它会在 500 毫秒后消失textField它就会消失。 …

我计划建立一个 MySQL 到 Kafka 的流程，最终目标是安排一个过程来根据更改的数据重新计算 mongoDB 文档。

这可能涉及直接修补 mongoDB 文档，或运行重新创建整个文档的进程。

我的问题是，如果对 MySQL 数据库的一组更改都与一个 mongoDB 文档相关，那么我不想为每个更改实时重新运行重新计算过程，我想等待更改“解决”，以便我只根据需要运行重新计算过程。

有没有办法“消除”卡夫卡流？例如，Kafka 消费者是否有一个明确定义的模式，我可以用它来实现我想要的逻辑？

我想使用 Observable<string[]> 在我的 Angular 应用程序的组件上逐渐显示内容。

1. 在TypeScript方面我声明了这一点：

export class ResultComponent implements OnInit{
 
 message: string = 'my message for user';
 spreadedMessage$: Observable<string> = from(this.message);
 progressiveMessage:string = "";

 ngOnInit() {
    let interval = 1
    this.obsMessage$
      .pipe(
        tap((letter) => {
           delay(35*interval),
           this.progressiveMessage += letter;
          interval++
        })
      )
      .subscribe();
    }
}

2. 将ProgressiveMessage绑定到模板

<div> {{ progressiveMessage }} </div>

我的完整代码清单可以在这里找到

我尝试了第二种方法，效果很好，如下所示，但我想了解我使用Observable来取得进展有什么问题。

我的替代解决方案：

1. 变成spreadedMessage$: Observable<string> = from(this.message);​spreadedMessage: string[] = [...this.message];

2. 在方法上声明了这一点OnInit()：

for (let i: number = 0; …