JQuery o JavaScript: come determinare se il tasto Maiusc viene premuto mentre si fa clic sul collegamento ipertestuale del tag di ancoraggio?

Ho un anchor tag che chiama una funzione JavaScript.

Con o senza JQuery come faccio a determinare se il tasto Maiusc è premuto mentre si fa clic sul collegamento?

Il codice seguente NON funziona perché la pressione del tasto viene attivata solo se viene premuto un "tasto reale" (non il tasto MAIUSC). (Speravo che si sarebbe attivato se fosse stato premuto solo il tasto Maiusc.)

var shifted = false;

$(function() {                           
    $(document).keypress(function(e) {
        shifted = e.shiftKey;
        alert('shiftkey='+e.shiftkey);
    });

    $(document).keyup(function(e) {
        shifted = false;
    });
}

...

function myfunction() {
  //shift is always false b/c keypress not fired above
}

    $(document).on('keyup keydown', function(e){shifted = e.shiftKey} );

Ecco il codice chiave per ogni battuta di tasto in JavaScript. Puoi usarlo e rilevare se l'utente ha premuto il tasto Maiusc.

backspace           8
tab                 9
enter               13
shift               16
ctrl                17
alt                 18
pause/break         19
caps lock           20
escape              27
page up             33
page down           34
end                 35
home                36
left arrow          37
up arrow            38
right arrow         39
down arrow          40
insert              45
delete              46
0                   48
1                   49
2                   50
3                   51
4                   52
5                   53
6                   54
7                   55
8                   56
9                   57
a                   65
b                   66
c                   67
d                   68
e                   69
f                   70
g                   71
h                   72
i                   73
j                   74
k                   75
l                   76
m                   77
n                   78
o                   79
p                   80
q                   81
r                   82
s                   83
t                   84
u                   85
v                   86
w                   87
x                   88
y                   89
z                   90
left window key     91
right window key    92
select key          93
numpad 0            96
numpad 1            97
numpad 2            98
numpad 3            99
numpad 4            100
numpad 5            101
numpad 6            102
numpad 7            103
numpad 8            104
numpad 9            105
multiply            106
add                 107
subtract            109
decimal point       110
divide              111
f1                  112
f2                  113
f3                  114
f4                  115
f5                  116
f6                  117
f7                  118
f8                  119
f9                  120
f10                 121
f11                 122
f12                 123
num lock            144
scroll lock         145
semi-colon          186
equal sign          187
comma               188
dash                189
period              190
forward slash       191
grave accent        192
open bracket        219
back slash          220
close braket        221
single quote        222

Non tutti i browser gestiscono bene l'evento di pressione dei tasti, quindi usa l'evento tasto su o tasto giù, in questo modo:

$(document).keydown(function (e) {
    if (e.keyCode == 16) {
        alert(e.which + " or Shift was pressed");
    }
});

Per gli eventi del mouse, so che in Firefox almeno la proprietà "shiftKey" sull'oggetto evento ti dirà se il tasto Maiusc è premuto. È documentato su MSDN ma non l'ho provato per sempre, quindi non ricordo se IE lo fa bene.

Quindi dovresti essere in grado di controllare "shiftKey" sull'oggetto evento nel tuo gestore "click".

Ho avuto un problema simile, cercando di catturare un 'shift + click' ma poiché stavo usando un controllo di terze parti con un callback piuttosto che il clickgestore standard , non avevo accesso all'oggetto evento e ai suoi associati e.shiftKey.

Ho finito per gestire l'evento mouse down per registrare lo spostamento e quindi utilizzarlo in seguito nella mia richiamata.

    var shiftHeld = false;
    $('#control').on('mousedown', function (e) { shiftHeld = e.shiftKey });

Inserito nel caso qualcun altro finisca qui a cercare una soluzione a questo problema.

L' keypressevento non viene attivato da tutti i browser quando fai clic su shifto ctrl, ma fortunatamente lo keydownè .

Se spegni il keypresscon keydownpotresti avere più fortuna.

Ho utilizzato un metodo per verificare se viene premuto un tasto specifico memorizzando i codici dei tasti attualmente premuti in un array:

var keysPressed = [],
    shiftCode = 16;

$(document).on("keyup keydown", function(e) {
    switch(e.type) {
        case "keydown" :
            keysPressed.push(e.keyCode);
            break;
        case "keyup" :
            var idx = keysPressed.indexOf(e.keyCode);
            if (idx >= 0)
                keysPressed.splice(idx, 1);
            break;
    }
});

$("a.shifty").on("click", function(e) {
    e.preventDefault();
    console.log("Shift Pressed: " + (isKeyPressed(shiftCode) ? "true" : "false"));
});

function isKeyPressed(code) {
    return keysPressed.indexOf(code) >= 0;
}

Ecco il jsfiddle

L'eccellente libreria JavaScript KeyboardJS gestisce tutti i tipi di pressione dei tasti incluso il tasto MAIUSC. Consente anche di specificare combinazioni di tasti come premere prima CTRL + x e poi a.

KeyboardJS.on('shift', function() { ...handleDown... }, function() { ...handleUp... });

Se vuoi una versione semplice, vai alla risposta di @tonycoupland ):

var shiftHeld = false;
$('#control').on('mousedown', function (e) { shiftHeld = e.shiftKey });

Questo funziona alla grande per me:

function listenForShiftKey(e){
    var evt = e || window.event;
    if (evt.shiftKey) {
      shiftKeyDown = true;
    } else {
      shiftKeyDown = false;
    }
}

Per controllare se il tasto shift viene premuto mentre si fa clic con il mouse , c'è una proprietà esatta nell'oggetto evento click : shiftKey (e anche per ctrl, alt e meta key): https://www.w3schools.com/jsref/event_shiftkey .asp

Quindi, usando jQuery:

$('#anchor').on('click', function (e) {
    if (e.shiftKey) {
        // your code
    }
});

Un approccio più modulare più la capacità di mantenere il tuo thisraggio d'azione negli ascoltatori:

var checkShift = function(fn, self) {
  return function(event) {
    if (event.shiftKey) {
      fn.call(self, event);
    }
    return true;
  };
};

$(document).on('keydown', checkShift(this.enterMode, this));

Se qualcuno sta cercando di rilevare una determinata chiave e ha bisogno di conoscere lo stato dei "modificatori" (come vengono chiamati in Java), cioè i tasti Shift, Alt e Control, puoi fare qualcosa del genere, che risponde al keydowntasto F9, ma solo se nessuno dei tasti Shift, Alt o Control è attualmente premuto.

jqMyDiv.on( 'keydown', function( e ){
    if( ! e.shiftKey && ! e.altKey && ! e.ctrlKey ){
        console.log( e );
        if( e.originalEvent.code === 'F9' ){
          // do something 
        }
    }
});

var shiftDown = false;
this.onkeydown = function(evt){
    var evt2 = evt || window.event;
    var keyCode = evt2.keyCode || evt2.which;       
    if(keyCode==16)shiftDown = true;
}
this.onkeyup = function(){
    shiftDown = false;
}

demo