Vérifiez si une touche est enfoncée?

Question

Y a-t-il un moyen de détecter si une touche est actuellement enfoncée en JavaScript?

Je connais l'événement "keydown", mais ce n'est pas ce dont j'ai besoin. Quelque temps APRES que la touche a été pressée, je veux être capable de détecter si elle est toujours enfoncée.

P. S. Le plus grand problème semble être qu'après un certain temps, la touche commence à se répéter, déclenchant des événements keydown et keyup comme un fou. Espérons qu'il existe simplement une fonction isKeyDown(touche), sinon ce problème devra être surmonté / contourné.

Answer 1

En plus d'utiliser les écouteurs keyup et keydown pour suivre quand une touche est enfoncée et remontée, il y a en fait certaines propriétés qui vous indiquent si certaines touches sont enfoncées.

window.onmousemove = function (e) {
  if (!e) e = window.event;
  if (e.shiftKey) {/*shift est enfoncée*/}
  if (e.altKey) {/*alt est enfoncée*/}
  if (e.ctrlKey) {/*ctrl est enfoncée*/}
  if (e.metaKey) {/*cmd est enfoncée*/}
}

Ces propriétés sont disponibles sur tous les objets d'événements générés par le navigateur, comme ceux de keydown, keyup et keypress, donc vous n'avez pas besoin d'utiliser mousemove.

J'ai essayé de générer mes propres objets d'événements avec document.createEvent('KeyboardEvent') et document.createEvent('KeyboardEvent') et de chercher e.shiftKey et ainsi de suite, mais je n'ai pas eu de chance.

J'utilise Chrome 17 sur Mac

Answer 2

Existe-t-il un moyen de détecter si une touche est actuellement enfoncée en JavaScript?

Non. La seule possibilité est de surveiller chaque keyup et keydown et de se souvenir.

après un certain laps de temps, la touche commence à se répéter, déclenchant des événements keydown et keyup comme un démon.

Ça ne devrait pas. Vous obtiendrez certainement des répétitions de keypress, et dans de nombreux navigateurs, vous obtiendrez également des répétitions de keydown, mais si keyup se répète, c'est un bug.

Malheureusement, ce n'est pas un bug complètement inconnu: sur Linux, Chromium, et Firefox (lorsqu'il est exécuté sous GTK+, comme c'est le cas dans des distributions populaires telles que Ubuntu) génèrent tous deux des séquences de répétition de keyup-keypress-keydown pour les touches maintenues, qu'il est impossible de distinguer de quelqu'un qui martèle la touche vraiment rapidement.

Answer 3

Je ne crois pas qu'il existe une fonction isKeyDown, mais vous pourriez écrire la vôtre.

Essentiellement, créez un tableau dont la longueur est le nombre de touches que vous voulez surveiller. Ensuite, en utilisant les événements keyUp et keyDown des documents/pages/contrôles, mettez à jour le tableau avec l'état de cette touche.

Ensuite, écrivez une fonction qui vérifie si une certaine touche est enfoncée et renvoie un booléen.

var keyEnum = { W_Key:0, A_Key:1, S_Key:2, D_Key:3 };
var keyArray = new Array(4);

function onKeyDown()
{
    // Détectez quelle touche a été pressée
    if( key == 'w' )
        keyArray[keyEnum.W_Key] = true;
    // Répétez pour chaque touche qui vous intéresse...
}

function onKeyUp()
{
    // Détectez quelle touche a été relâchée
    if( key == 'w' )
        keyArray[keyEnum.W_Key] = false;
    // Répétez pour chaque touche qui vous intéresse...
}

function isKeyDown(key)
{
    return keyArray[key];
}

Cela devrait accomplir ce que vous voulez.

Answer 4

/*
Suites des touches qui sont actuellement enfoncées sur le clavier
*/

function keyboard_module(onUpdate){
    var kb = {};
    var unicode_mapping = {};
    document.onkeydown = function(e){
        var unicode=e.charCode? e.charCode : e.keyCode
        var key = getKey(unicode);
        kb[key] = true;
        if(onUpdate){
            onUpdate(kb);
        }
    }

    document.onkeyup = function(e){
        var unicode=e.charCode? e.charCode : e.keyCode
        var key = getKey(unicode);
        delete kb[key];
        if(onUpdate){
            onUpdate(kb);
        }
    }

    function getKey(unicode){
        if(unicode_mapping[unicode]){
            var key = unicode_mapping[unicode];
        }else{
            var key= unicode_mapping[unicode] = String.fromCharCode(unicode);
        }
        return key;
    }
    return kb;
}

function testing(kb){
    console.log('Ce sont les touches enfoncées :', kb);
}

var keyboard = keyboard_module(testing);

....
//ailleurs dans le code
if(keyboard['K']){/*faire quelque chose de spécial */}

Answer 5

D'autres personnes ont posé ce genre de question auparavant (bien que je ne voie aucun doublon évident ici pour le moment).

Je pense que la réponse est que l'événement keydown (et son jumeau keyup) sont toutes les informations que vous obtenez. La répétition est bien intégrée dans le système d'exploitation, et un programme d'application n'a pas beaucoup l'opportunité d'interroger le BIOS pour l'état réel de la touche.

Ce que vous pouvez faire, et peut-être devez faire si vous avez besoin que cela fonctionne, c'est de débouncer de manière programmatique la touche. Essentiellement, vous pouvez évaluer keydown et keyup vous-même mais ignorer un événement keyup s'il se produit trop rapidement après le dernier keydown... ou essentiellement, vous devriez retarder votre réponse au keyup assez longtemps pour être sûr qu'il n'y a pas un autre événement keydown suivant avec quelque chose comme 0.25 secondes du keyup.

Cela impliquerait d'utiliser une activité de minuterie et d'enregistrer les temps en millisecondes des événements précédents. Je ne peux pas dire que ce soit une solution très attrayante, mais...