12

目标是手动设置保持键的“重复率”。

例如,当在文本框中按住 X 键时,我知道有浏览器特定的方法可以重复按下的字符。在某些情况下,它会暂停,然后连续触发按下的键。在其他情况下,它根本不会重复。我想通过强制按下的键以特定间隔重复来缓解这种情况,而不管浏览器如何。

通过研究,我想出了一个基于计时器的尝试,但在 Safari 中,它不会重复字符。我有一个菜单系统,其中按住箭头滚动列表,但翻译动画和重复率彼此不喜欢。

var repeating = false;
var repeatRateTimer = null;

$( document ).bind( 'keyup', function( input ) {
    if( repeatRateTimer != null )
    {
        clearTimeout( repeatRateTimer );
        repeatRateTimer = null;
    }

    repeating = false;
} );

$( document ).bind( 'keydown', function( input ) {
    input.preventDefault( );

    if( repeating == true )
    {
        if( repeatRateTimer != null )
        {
            clearTimeout( repeatRateTimer );
            repeatRateTimer = null;
        }
        else
        {
            repeatRateTimer = setTimeout( function( ){ repeating = false; }, 1000 );
        }

        return;
    }
    repeating = true;

    // ...keyboard logic
} );

我可能把这整件事搞砸了……我试图重新创建这个 SO 帖子的简化版本。但是,我觉得必须更好的方法来做到这一点。有什么想法吗?

更新:

我们可以假设最终用户没有将他们的操作系统键盘重复率设置为大于我想要使用的频率(1000 毫秒)。如果是,那么它应该回退到它们的重复率,因为它不会继续触发按键事件。如果不是(更有可能,因为大多数人不会修改它),那么我们将覆盖该行为以使其延迟我们指定的时期。

4

4 回答 4

5

查看以下JavaScript 文件。如果你向下滚动到第 530 行,你会发现以下类:

var Keyboard = new Class(function (constructor) {
    var key = {};

    var eventListener = {
        keyup: {},
        keydown: {},
        keypress: {}
    };

    constructor.overload(["Number"], function (interval) {
        setInterval(keypress, interval);
    });

    window.addEventListener("keyup", keyup, false);
    window.addEventListener("keydown", keydown, false);

    function keyup(event) {
        var keyCode = event.keyCode;
        var listener = eventListener.keyup[keyCode];
        key[keyCode] = false;
        if (listener)
        listener();
    }

    function keydown(event) {
        var keyCode = event.keyCode;
        var listener = eventListener.keydown[keyCode];
        key[keyCode] = true;
        if (listener)
        listener();
    }

    function keypress() {
        for (var code in key) {
            var listener = eventListener.keypress[code];
            if (key[code] && listener) listener();
        }
    }

    this.addEventListener = new Dispatcher(["String", "Number", "Function"], function (type, keyCode, listener) {
        type = eventListener[type];
        if (type) type[keyCode] = listener;
        else throw new Error("Unexpected value for type.");
    });
});

作者所做的是他创建了一个特殊的Keyboard类来委派关键事件keyupkeydownkeypress。该类只有一个构造函数,它接受一个参数 -keypress事件的间隔(这是你想要的)。addEventListener您可以使用类实例的方法添加事件侦听器Keyboard

var keyboard = new Keyboard(125); // fire key press 8 times a second.

keypress.addEventListener("keypress", 65, function () {
    // do something every time A is pressed
});

请注意,上述类依赖于以下框架:Lambda JS您可以在此处查看上述脚本的工作演示。希望这可以帮助。

更新1:

您的代码在 Opera 中不起作用。此外,第二个事件在 Firefox 中额外延迟 500 毫秒后触发,并且连续事件不会保持相同的间隔。另外它不能同时处理多个关键事件。让我们纠正这个问题:

首先,我们需要为Delta Timing创建一个简单的脚本,以便在恒定间隔后触发关键事件。我们使用以下代码片段来创建DeltaTimer

function DeltaTimer(render, interval) {
    var timeout;
    var lastTime;

    this.start = start;
    this.stop = stop;

    function start() {
        timeout = setTimeout(loop, 0);
        lastTime = Date.now();
        return lastTime;
    }

    function stop() {
        clearTimeout(timeout);
        return lastTime;
    }

    function loop() {
        var thisTime = Date.now();
        var deltaTime = thisTime - lastTime;
        var delay = Math.max(interval - deltaTime, 0);
        timeout = setTimeout(loop, delay);
        lastTime = thisTime + delay;
        render(thisTime);
    }
}

接下来我们编写触发自定义keypressed事件的逻辑。我们需要自定义事件,因为我们必须能够同时处理多个键:

(function (interval) {
    var keyboard = {};

    window.addEventListener("keyup", keyup, false);
    window.addEventListener("keydown", keydown, false);

    function keyup(event) {
        keyboard[event.keyCode].pressed = false;
    }

    function keydown(event) {
        var keyCode = event.keyCode;
        var key = keyboard[keyCode];

        if (key) {
            if (!key.start)
                key.start = key.timer.start();
            key.pressed = true;
        } else {
            var timer = new DeltaTimer(function (time) {
                if (key.pressed) {
                    var event = document.createEvent("Event");
                    event.initEvent("keypressed", true, true);
                    event.time = time - key.start;
                    event.keyCode = keyCode;
                    window.dispatchEvent(event);
                } else {
                    key.start = 0;
                    timer.stop();
                }
            }, interval);

            key = keyboard[keyCode] = {
                pressed: true,
                timer: timer
            };

            key.start = timer.start();
        }
    }
})(1000);

interval设置为1000ms,但您可以更改它。最后注册一个我们做的事件:

window.addEventListener("keypressed", function (event) {
    document.body.innerHTML += event.keyCode + " (" + event.time + " ms)<br/>";
}, false);

这是简单而高效的 JavaScript。不需要 jQuery。你可以在这里看到现场演示,看看你的脚本和我的脚本之间的区别。干杯。

更新 2:

查看 StackOverflow 上的另一个问题,这是使用上述模式实现它的方式:

window.addEventListener("keypressed", function (event) {
    switch (event.keyCode) {
    case 37:
        Move(-1, 0);
        break;
    case 38:
        Move(0, -1);
        break;
    case 39:
        Move(1, 0);
        break;
    case 40:
        Move(0, 1);
        break;
    }
}, false);

使用上面的代码将消除您遇到的短暂延迟,并允许同时为不同的键触发多个事件。

于 2012-07-06T04:54:44.770 回答
5

好吧,我弄清楚了为什么我的示例没有循环。在 keydown 循环中,它在超时之前清除超时:

if( repeatRateTimer != null )
{
    clearTimeout( repeatRateTimer );
    repeatRateTimer = null;
}
else
{
    repeatRateTimer = setTimeout( function( ){ repeating = false; }, 1000 );
}

超时应该只有在它到期后才被清除,因此if需要将条件移到超时函数中:

if( repeatRateTimer == null )
{
    repeatRateTimer = setTimeout( function( ) {
        repeating = false;
        clearTimeout( repeatRateTimer );
        repeatRateTimer = null;
    }, 1000 );
}

如果有人可以对此进行改进,或者提供更好的选择,我将保留此赏金。

于 2012-07-08T14:37:36.197 回答
2

您如何制作自定义键事件。您可以收听原始的(keyup/keydown),如果它们通过时间条件,您将触发您的自定义事件。
这种方式的好处是您不依赖计时器并且它为您提供更多功能,因为您使用自定义事件(顺便说一句,如果您愿意,您可以跳过取消事件部分)。
这是一个演示,看看我在说什么:http: //jsfiddle.net/gion_13/gxEMz/
基本代码如下所示:

$(document).ready(function(){
    var dispatcher = $(window),
        keyRate = 1000, //ms
        lastKeyEvent = 0,
        cancelEvent = function(e){
            var evt = e ? e:window.event;
            if(evt.stopPropagation)    
                evt.stopPropagation();
            if(evt.cancelBubble!=null) 
                evt.cancelBubble = true;
            return false;
        };

    dispatcher
        .bind('keydown',function(e){
            var now = new Date().getTime();
            if(now - lastKeyEvent <= keyRate)
                // cancel the event
                return cancelEvent(e);
            var keyEventsTimeDiff = now - lastKeyEvent;
            lastKeyEvent = now;
            dispatcher.trigger('special-keydown',[e,keyEventsTimeDiff ]);
        })
        .bind('keyup',function(e){
            cancelEvent(e);
            dispatcher.trigger('special-keyup',[e]);
        })
        // binding the custom events
        .bind('special-keydown',function(e,keyEventsTimeDiff){
            console.log(e,'special keydown triggered again after ' + keyEventsTimeDiff +'ms');
        })
       .bind('special-keyup',function(e,keyEventsTimeDiff){
            console.log(e,'special keyup');
        });
});
于 2012-07-08T14:44:31.217 回答
0

这是一篇旧帖子,但我想与 rxjs 分享我当前的答案。我必须用 Javascript 做一个俄罗斯方块游戏,我想改变按键重复延迟以获得更好的游戏玩法。

事实上,我们不能覆盖操作系统特有的真正的 keydown 重复延迟属性。然而,我们可以通过 keyup 和 keydown 事件来模拟它。

最后,我想出了这个(打字稿):

function keyDown$(key: KeyboardKey): Observable<KeyboardEvent> {
  return fromEvent<KeyboardEvent>(document, 'keydown').pipe(filter(event => event.key === key));
}

function keyUp$(key: KeyboardKey): Observable<KeyboardEvent> {
  return fromEvent<KeyboardEvent>(document, 'keyup').pipe(filter(event => event.key === key));
}

export function keyPressed$(key: KeyboardKey): Observable<KeyboardEvent> {
  return merge(keyDown$(key), keyUp$(key)).pipe(
    filter(event => event.repeat === false),
    switchMap(event => (event.type === 'keydown' ? merge(of(event), timer(150, 50).pipe(mapTo(event))) : NEVER))
  );
}

...

keyPressed$('ArrowRight').subscribe({
  next: (event) => {
    ...
  }
});

JS 版本:

function keyDown$(key) {
  return fromEvent(document, 'keydown').pipe(filter(event => event.key === key));
}

function keyUp$(key) {
  return fromEvent(document, 'keyup').pipe(filter(event => event.key === key));
}

export function keyPressed$(key) {
  return merge(keyDown$(key), keyUp$(key)).pipe(
    filter(event => event.repeat === false),
    switchMap(event => (event.type === 'keydown' ? merge(of(event), timer(150, 50).pipe(mapTo(event))) : NEVER))
  );
}

...

keyPressed$('ArrowRight').subscribe({
  next: (event) => {
    ...
  }
});

keyPressed$函数将键盘键作为参数并返回一个可观察对象。当按下相应的键时,这个 observable 会立即发射,然后等待 150 毫秒,然后每 50 毫秒发射一次。

您可以在计时器功能中为您的情况更改这些值。

不要忘记取消订阅 observable。

于 2021-04-12T08:21:51.100 回答