JQuery ou JavaScript: como determinar se a tecla shift está sendo pressionada ao clicar no hiperlink da marca âncora?

Eu tenho uma tag âncora que chama uma função JavaScript.

Com ou sem JQuery, como posso determinar se a tecla shift está pressionada enquanto o link é clicado?

O código a seguir NÃO funciona porque o pressionamento de tecla só é acionado se uma "tecla real" (não a tecla shift) for pressionada. (Eu esperava que ele disparasse se apenas a tecla shift fosse pressionada.)

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} );

Aqui está o código de cada tecla em JavaScript. Você pode usar isso e detectar se o usuário pressionou a tecla Shift.

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

Nem todos os navegadores lidam bem com o evento keypress, então use o evento key up ou key down, assim:

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

Para eventos de mouse, sei que, no Firefox, pelo menos a propriedade "shiftKey" no objeto de evento informará se a tecla shift está pressionada. Está documentado no MSDN, mas não o experimento há muito tempo, então não me lembro se o IE faz isso direito.

Portanto, você deve ser capaz de verificar se há "shiftKey" no objeto de evento em seu manipulador de "clique".

Tive um problema semelhante ao tentar capturar um 'shift + clique', mas como estava usando um controle de terceiros com um retorno de chamada em vez do clickmanipulador padrão , não tive acesso ao objeto de evento e seus associados e.shiftKey.

Acabei manipulando o evento do mouse para baixo para registrar a mudança e, em seguida, usando-o mais tarde em meu retorno de chamada.

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

Postado para o caso de alguém vir aqui em busca de uma solução para esse problema.

O keypressevento não é disparado por todos os navegadores quando você clica em shiftou ctrl, mas felizmente o keydownevento é .

Se você trocar o keypresscom, keydowntalvez tenha mais sorte.

Usei um método para testar se alguma tecla específica foi pressionada, armazenando os códigos de tecla pressionados atualmente em uma matriz:

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;
}

Aqui está o jsfiddle

A excelente biblioteca JavaScript KeyboardJS lida com todos os tipos de pressionamento de tecla, incluindo a tecla SHIFT. Ele ainda permite especificar combinações de teclas, como primeiro pressionar CTRL + x e, em seguida, a.

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

Se você quiser uma versão simples, vá para a resposta de @tonycoupland ):

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

Isso funciona muito bem para mim:

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

Para verificar se a tecla shift é pressionada enquanto clica com o mouse , existe uma propriedade exata no objeto de evento de clique : shiftKey (e também para ctrl e alt e meta key): https://www.w3schools.com/jsref/event_shiftkey .asp

Então, usando jQuery:

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

Uma abordagem mais modular mais a capacidade de manter seu thisescopo nos ouvintes:

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 alguém está procurando detectar uma determinada tecla e precisa saber o status dos "modificadores" (como são chamados em Java), ou seja, as teclas Shift, Alt e Control, você pode fazer algo assim, que responde à keydowntecla F9, mas apenas se nenhuma das teclas Shift, Alt ou Control estiver pressionada no momento.

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