JQuery o JavaScript: ¿Cómo determinar si se presiona la tecla Mayús mientras se hace clic en el hipervínculo de la etiqueta de anclaje?

Tengo una etiqueta de anclaje que llama a una función de JavaScript.

Con o sin JQuery, ¿cómo puedo determinar si la tecla Mayús está presionada mientras se hace clic en el enlace?

El siguiente código NO funciona porque la pulsación de teclas solo se activa si se pulsa una "tecla real" (no la tecla Mayús). (Esperaba que se disparara si solo se presionaba la tecla Mayús).

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

Aquí está el código clave para cada pulsación de tecla en JavaScript. Puede usar eso y detectar si el usuario ha presionado la 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

No todos los navegadores manejan bien el evento keypress, así que use el evento key up o key down, así:

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

Para los eventos del mouse, sé que en Firefox al menos la propiedad "shiftKey" en el objeto de evento le dirá si la tecla shift está presionada. Está documentado en MSDN pero no lo he probado desde hace mucho tiempo, así que no recuerdo si IE lo hace bien.

Por lo tanto, debería poder verificar "shiftKey" en el objeto de evento en su controlador de "clic".

Tuve un problema similar al intentar capturar un 'shift + click' pero como estaba usando un control de terceros con una devolución de llamada en lugar del clickcontrolador estándar , no tenía acceso al objeto de evento y su asociado e.shiftKey.

Terminé manejando el evento de mouse down para registrar el shift-ness y luego usándolo más tarde en mi devolución de llamada.

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

Publicado por si acaso alguien más termina aquí buscando una solución a este problema.

El keypressevento no es activado por todos los navegadores cuando hace clic en shifto ctrl, pero afortunadamente el keydownevento es .

Si cambia el keypresscon, keydownes posible que tenga mejor suerte.

He usado un método para probar si se presiona alguna tecla específica almacenando los códigos de tecla presionados actualmente en una 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;
}

Aquí está el jsfiddle

La excelente biblioteca de JavaScript KeyboardJS maneja todo tipo de pulsaciones de teclas, incluida la tecla MAYÚS. Incluso permite especificar combinaciones de teclas, como presionar primero CTRL + xy luego a.

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

Si desea una versión simple, diríjase a la respuesta de @tonycoupland ):

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

Esto funciona muy bien para mí:

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

Para verificar si se presiona la tecla shift mientras se hace clic con el mouse , hay una propiedad exacta en el objeto de evento de clic : shiftKey (y también para ctrl y alt y meta key): https://www.w3schools.com/jsref/event_shiftkey .áspid

Entonces usando jQuery:

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

Un enfoque más modular más la capacidad de mantener su thisalcance en los oyentes:

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

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

Si alguien busca detectar una tecla determinada y necesita conocer el estado de los "modificadores" (como se llaman en Java), es decir, las teclas Shift, Alt y Control, puede hacer algo como esto, que responde a la keydowntecla F9, pero solo si ninguna de las teclas Shift, Alt o Control está presionada actualmente.

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

manifestación