We Keep Coding

How can I hit multiple html buttons at once in javascript?

I can click the arrow buttons on the web page, but multiple buttons cannot be read at the same time.If I click on 37 and 39 keys it does not work but only when I click on 37 keys it works. Same goes for other keys, how can I control more than one button at the same time?
const handleArrowButtonMouseDown = function() {
$('button').on('mousedown touchstart', (e) => {
e.preventDefault();
if(state.arrowPressed) return;
let direction = $(e.target).closest('button').attr('id');
state.setArrowPressed(direction);
state.setRobotCommand();
});
};
const handleArrowButtonMouseUp = function() {
$('button').on('mouseup mouseleave touchend', endCurrentOperation);
};
const handleArrowKeyDown = function() {
$(document).keydown((e) => {
if(state.arrowPressed) return;
switch(e.which) {
case 37:
state.setArrowPressed('left');
break;
case 38:
state.setArrowPressed('up');
break;
case 39:
state.setArrowPressed('right');
break;
case 40: // down
state.setArrowPressed('down');
break;
default: return;
}
e.preventDefault();
state.setRobotCommand();
});
};
const handleArrowKeyUp = function() {
$(document).keyup((e) => {
if (e.which === 37 && state.arrowPressed !== 'left') return;
if (e.which === 38 && state.arrowPressed !== 'up') return;
if (e.which === 39 && state.arrowPressed !== 'right') return;
if (e.which === 40 && state.arrowPressed !== 'down') return;
endCurrentOperation();
});
};

There is one way, but it's not safe to rely on, since you cannot detect if a key is currently down in JavaScript.
The example below works only with Shift + Number. It's closest to achieve when both keys are pressed.
window.addEventListener("keydown", function (event) {
if (event.shiftKey) {
if (/\d/.test(event.code)){
console.log("SHIFTKEY + Number:"+event.code);
}
}
}, true)
Maybe you can repeat the same login to your code.

jQuery event: keypress not working with Firefox or IE, and keyup not working with IE [duplicate]

How do I detect when one of the arrow keys are pressed? I used this to find out:
function checkKey(e) {
var event = window.event ? window.event : e;
console.log(event.keyCode)
}
Though it worked for every other key, it didn't for arrow keys (maybe because the browser is supposed to scroll on these keys by default).

Arrow keys are only triggered by onkeydown, not onkeypress.
The keycodes are:
left = 37
up = 38
right = 39
down = 40

On key up and down call function. There are different codes for each key.
document.onkeydown = checkKey;
function checkKey(e) {
e = e || window.event;
if (e.keyCode == '38') {
// up arrow
}
else if (e.keyCode == '40') {
// down arrow
}
else if (e.keyCode == '37') {
// left arrow
}
else if (e.keyCode == '39') {
// right arrow
}
}

event.key === "ArrowRight"...
More recent and much cleaner: use event.key. No more arbitrary number codes! If you are transpiling or know your users are all on modern browsers, use this!
node.addEventListener('keydown', function(event) {
const key = event.key; // "ArrowRight", "ArrowLeft", "ArrowUp", or "ArrowDown"
});
Verbose Handling:
switch (event.key) {
case "ArrowLeft":
// Left pressed
break;
case "ArrowRight":
// Right pressed
break;
case "ArrowUp":
// Up pressed
break;
case "ArrowDown":
// Down pressed
break;
}
Modern Switch Handling:
const callback = {
"ArrowLeft" : leftHandler,
"ArrowRight" : rightHandler,
"ArrowUp" : upHandler,
"ArrowDown" : downHandler,
}[event.key]
callback?.()
NOTE: The old properties (.keyCode and .which) are Deprecated.
"w", "a", "s", "d" for direction, use event.code
To support users who are using non-qwerty/English keyboard layouts, you should instead use event.code. This will preserve physical key location, even if resulting character changes.
event.key would be , on Dvorak and z on Azerty, making your game unplayable.
const {code} = event
if (code === "KeyW") // KeyA, KeyS, KeyD
Optimally, you also allow key remapping, which benefits the player regardless of their situation.
P.S. event.code is the same for arrows
key Mozilla Docs
code Mozilla Docs
Supported Browsers

Possibly the tersest formulation:
document.onkeydown = function(e) {
switch (e.keyCode) {
case 37:
alert('left');
break;
case 38:
alert('up');
break;
case 39:
alert('right');
break;
case 40:
alert('down');
break;
}
};
Demo (thanks to user Angus Grant): http://jsfiddle.net/angusgrant/E3tE6/
This should work cross-browser. Leave a comment if there is a browser where it does not work.
There are other ways to get the key code (e.which, e.charCode, and window.event instead of e), but they should not be necessary. You can try most of them out at http://www.asquare.net/javascript/tests/KeyCode.html.
Note that event.keycode does not work with onkeypress in Firefox, but it does work with onkeydown.

Use keydown, not keypress for non-printable keys such as arrow keys:
function checkKey(e) {
e = e || window.event;
alert(e.keyCode);
}
document.onkeydown = checkKey;
The best JavaScript key event reference I've found (beating the pants off quirksmode, for example) is here: http://unixpapa.com/js/key.html

Modern answer since keyCode is now deprecated in favor of key:
document.onkeydown = function (e) {
switch (e.key) {
case 'ArrowUp':
// up arrow
break;
case 'ArrowDown':
// down arrow
break;
case 'ArrowLeft':
// left arrow
break;
case 'ArrowRight':
// right arrow
}
};

I believe the most recent method would be:
document.addEventListener("keydown", function(event) {
event.preventDefault();
const key = event.key; // "ArrowRight", "ArrowLeft", "ArrowUp", or "ArrowDown"
switch (key) { // change to event.key to key to use the above variable
case "ArrowLeft":
// Left pressed
<do something>
break;
case "ArrowRight":
// Right pressed
<do something>
break;
case "ArrowUp":
// Up pressed
<do something>
break;
case "ArrowDown":
// Down pressed
<do something>
break;
}
});
This assumes the developer wants the code to be active anywhere on the page and the client should ignore any other key presses. Eliminate the event.preventDefault(); line if keypresses, including those caught by this handler should still be active.

function checkArrowKeys(e){
var arrs= ['left', 'up', 'right', 'down'],
key= window.event? event.keyCode: e.keyCode;
if(key && key>36 && key<41) alert(arrs[key-37]);
}
document.onkeydown= checkArrowKeys;

Here's an example implementation:
var targetElement = $0 || document.body;
function getArrowKeyDirection (keyCode) {
return {
37: 'left',
39: 'right',
38: 'up',
40: 'down'
}[keyCode];
}
function isArrowKey (keyCode) {
return !!getArrowKeyDirection(keyCode);
}
targetElement.addEventListener('keydown', function (event) {
var direction,
keyCode = event.keyCode;
if (isArrowKey(keyCode)) {
direction = getArrowKeyDirection(keyCode);
console.log(direction);
}
});

Here's how I did it:
var leftKey = 37, upKey = 38, rightKey = 39, downKey = 40;
var keystate;
document.addEventListener("keydown", function (e) {
keystate[e.keyCode] = true;
});
document.addEventListener("keyup", function (e) {
delete keystate[e.keyCode];
});
if (keystate[leftKey]) {
//code to be executed when left arrow key is pushed.
}
if (keystate[upKey]) {
//code to be executed when up arrow key is pushed.
}
if (keystate[rightKey]) {
//code to be executed when right arrow key is pushed.
}
if (keystate[downKey]) {
//code to be executed when down arrow key is pushed.
}

I've been able to trap them with jQuery:
$(document).keypress(function (eventObject) {
alert(eventObject.keyCode);
});
An example: http://jsfiddle.net/AjKjU/

That is the working code for chrome and firefox
<html>
<head>
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.1/jquery.min.js"></script>
<script type="text/javascript">
function leftArrowPressed() {
alert("leftArrowPressed" );
window.location = prevUrl
}
function rightArrowPressed() {
alert("rightArrowPressed" );
window.location = nextUrl
}
function topArrowPressed() {
alert("topArrowPressed" );
window.location = prevUrl
}
function downArrowPressed() {
alert("downArrowPressed" );
window.location = nextUrl
}
document.onkeydown = function(evt) {
var nextPage = $("#next_page_link")
var prevPage = $("#previous_page_link")
nextUrl = nextPage.attr("href")
prevUrl = prevPage.attr("href")
evt = evt || window.event;
switch (evt.keyCode) {
case 37:
leftArrowPressed(nextUrl);
break;
case 38:
topArrowPressed(nextUrl);
break;
case 39:
rightArrowPressed(prevUrl);
break;
case 40:
downArrowPressed(prevUrl);
break;
}
};
</script>
</head>
<body>
<p>
<a id="previous_page_link" href="http://www.latest-tutorial.com">Latest Tutorials</a>
<a id="next_page_link" href="http://www.zeeshanakhter.com">Zeeshan Akhter</a>
</p>
</body>
</html>

Arrow Keys are triggered on keyup
$(document).on("keyup", "body", function(e) {
if (e.keyCode == 38) {
// up arrow
console.log("up arrow")
}
if (e.keyCode == 40) {
// down arrow
console.log("down arrow")
}
if (e.keyCode == 37) {
// left arrow
console.log("lefy arrow")
}
if (e.keyCode == 39) {
// right arrow
console.log("right arrow")
}
})
onkeydown allows ctrl, alt, shits
onkeyup allows tab, up arrows, down arrows, left arrows, down arrows

I was also looking for this answer until I came across this post.
I've found another solution to know the keycode of the different keys, courtesy to my problem. I just wanted to share my solution.
Just use keyup/keydown event to write the value in the console/alert the same using event.keyCode. like-
console.log(event.keyCode)
// or
alert(event.keyCode)
- rupam

That's shorter.
function IsArrows (e) {
return (e.keyCode >= 37 && e.keyCode <= 40);
}

This library rocks!
https://craig.is/killing/mice
Mousetrap.bind('up up down down left right left right b a enter', function() {
highlight([21, 22, 23]);
});
You need to press the sequence a bit fast to highlight the code in that page though.

With key and ES6.
This gives you a separate function for each arrow key without using switch and also works with the 2,4,6,8 keys in the numpad when NumLock is on.
const element = document.querySelector("textarea"),
ArrowRight = k => {
console.log(k);
},
ArrowLeft = k => {
console.log(k);
},
ArrowUp = k => {
console.log(k);
},
ArrowDown = k => {
console.log(k);
},
handler = {
ArrowRight,
ArrowLeft,
ArrowUp,
ArrowDown
};
element.addEventListener("keydown", e => {
const k = e.key;
if (handler.hasOwnProperty(k)) {
handler[k](k);
}
});
<p>Click the textarea then try the arrows</p>
<textarea></textarea>

Re answers that you need keydown not keypress.
Assuming you want to move something continuously while the key is pressed, I find that keydown works for all browsers except Opera. For Opera, keydown only triggers on 1st press. To accommodate Opera use:
document.onkeydown = checkKey;
document.onkeypress = checkKey;
function checkKey(e)
{ etc etc

If you use jquery then you can also do like this,
$(document).on("keydown", '.class_name', function (event) {
if (event.keyCode == 37) {
console.log('left arrow pressed');
}
if (event.keyCode == 38) {
console.log('up arrow pressed');
}
if (event.keyCode == 39) {
console.log('right arrow pressed');
}
if (event.keyCode == 40) {
console.log('down arrow pressed');
}
});

control the Key codes %=37 and &=38... and only arrow keys left=37 up=38
function IsArrows (e) {
return ( !evt.shiftKey && (e.keyCode >= 37 && e.keyCode <= 40));
}

If you want to detect arrow keypresses but not need specific in Javascript
function checkKey(e) {
if (e.keyCode !== 38 || e.keyCode !== 40 || e.keyCode !== 37 || e.keyCode !== 39){
// do something
};
}

How to implement user-customizable keyboard shortcuts (in javascript/on the web)

The title says most of it. I'd like a javascript/html solution for how to make persistent, user-configurable keyboard shortcut listeners (plus any nice thoughts on how to actually persist the preferences if you have 'em).
It seems both straightforward and slightly tricky at the same time :)
Thanks!

If you want to allow the user get shortcuts like "Control"+(...), you just have to capture the keys pressed, so check if "Control" is pressed with such keys pressed to do an action.
This is an simple and bad example of doing this:
var Pressed={
CTRL:false,
Spacebar:false
},Keyboard={ // an object containing Keyboard keys code
CTRL:17,
Spacebar:32
};
window.onkeydown=function(e){ // user started pressing an key (event)
var Key=(e.keyCode||e.which||e.key); // capture key pressed from event
if(Key==Keyboard.CTRL){ // CTRL is pressed
Pressed.CTRL=true
Pressed.Spacebar=false // CTRL has to be pressed before than Spacebar
}else if(Key==Keyboard.Spacebar){ // Spacebar is pressed
Pressed.Spacebar=true
}
if(Pressed.CTRL&&Pressed.Spacebar){ // Case CTRL+Spacebar are pressed
e.preventDefault(); // prevent Opera from quitting from the page
console.log("CTRL+Spacebar were pressed.")
}
},
window.onkeyup=function(e){ // event when an key is released
var Key=(e.keyCode||e.which||e.key); // capture key released from event
if(Key==Keyboard.CTRL){ // CTRL is released
Pressed.CTRL=false
}else if(Key==Keyboard.Spacebar){ // Spacebar is released
Pressed.Spacebar=false
}
};
To update...

You can try something like this:
For demo purpose, I have just logged if Alt, Ctrl or Shift + 'Key' and if key is defined in shortcuts, then print Special action else 'Normal action'. Also I have disabled propagation of key events for inputs, but this section can be removed if not required.
JSFiddle
Code
(function keyLogger() {
var isCtrlPressed = false;
var isAltPressed = false;
var isShiftPressed = false;
var shortcutKeys = [
13, // Enter
32, // Space
37, // Left Arrow
38, // Up Arrow
39, // Right Arrow
40, // Down Arrow
90, // z
]
function registerEvents() {
document.onkeydown = function(event) {
var keyCode = event.keyCode ? event.keyCode : event.which;
if (keyCode >= 16 && keyCode <= 18) {
updateKeyFlags(keyCode, true);
}
if (isCtrlPressed || isAltPressed || isShiftPressed) {
if (shortcutKeys.indexOf(keyCode) >= 0) {
console.log("Special action");
} else {
console.log("Normal action");
}
}
}
document.onkeyup = function(event) {
var keyCode = event.keyCode ? event.keyCode : event.which;
if (keyCode >= 16 && keyCode <= 18) {
updateKeyFlags(keyCode, false);
}
}
// To prevent logging from Inputs.
// Can be removed if this action is required.
var inputs = document.getElementsByTagName("input");
for (var i in inputs) {
inputs[i].onkeyup = function(event) {
event.stopPropagation();
}
inputs[i].onkeydown = function(event) {
event.stopPropagation();
}
}
}
function updateKeyFlags(keyCode, flag) {
switch (keyCode) {
case 16:
isShiftPressed = flag;
break;
case 17:
isCtrlPressed = flag;
break;
case 18:
isAltPressed = flag;
break;
}
}
registerEvents();
})();
<div>
<input type="text">
<input type="text">
</div>

javascript keypress to control animation

Space Invader game: I want to control the 'base gun' (move it left and right and fire missiles at the invaders. So I need a keypress or (keydown?) event to change a variable (x coordinate) and a key press event to fire a missile.
Can anyone show me how the keypress event is detected and the variable is changed?

document.onkeydown = function(e) {
var key = e.keyCode;
if (key===37) {//left arrow pressed
} else if (key===39) {//right arrow pressed
}
}

Like this?
document.onkeydown = checkKey;
var xCoord = 100;
function checkKey(e) {
e = e || window.event;
switch (e.keyCode) {
case 37 : // left
xCoord -= 5;
break;
case 39 : // right
xCoord += 5;
break;
}
}
Exciting fiddle: http://jsfiddle.net/u5eJp/

Couple things I would like to add to the other answers:
1) Use constants to make it easier on yourself
2) There is no way to check if a key is currently pressed in javascript, so you should keep track of what is currently pressed as well
var pressed = {
up: false,
down: false,
left: false,
right: false
};
var LEFT_ARROW = 37;
var UP_ARROW = 38;
var RIGHT_ARROW = 39;
var DOWN_ARROW = 40;
document.onkeydown = function (e) {
e = e || window.event;
switch (e.keyCode) {
case LEFT_ARROW:
pressed.left = true;
break;
case UP_ARROW:
pressed.up = true;
break;
case RIGHT_ARROW:
pressed.right = true;
break;
case DOWN_ARROW:
pressed.down = true;
break;
default:
break;
}
}
//update position separately
function updatePos() {
if (pressed.up) { //change y up }
if (pressed.down) { //change y down }
if (pressed.left) { //change x left }
if (pressed.right) { //change x right }
}
Hope this helps, and good luck!

Web page change when left or right arrow in keyboard pushed

i want to ask how can i change the web page when the arrow key pushed by user , like a web of manga/book if we want to next page we just push the arrow key
sorry for my english , thanks before

You can use jQuery for that:
$(document).keydown(function(e) {
if (e.which == 37) {
alert("left");
e.preventDefault();
return false;
}
if (e.which == 39) {
alert("right");
e.preventDefault();
return false;
}
});

If you wish to use the jQuery framework, then look at Binding arrow keys in JS/jQuery
In plain javascript, I'll go with :
document.onkeydown = function (e) {
e = e || window.event;
var charCode = (e.charCode) ? e.charCode : e.keyCode;
if (charCode == 37) {
alert('left');
}
else if (charCode == 39) {
alert('right');
}
};

Here is a non jQuery option:
document.onkeydown = arrowChecker;
function arrowChecker(e) {
e = e || window.event;
if (e.keyCode == '37') { //left
document.location.href = "http://stackoverflow.com/";
}
else if (e.keyCode == '39') { //right
document.location.href = "http://google.com/";
}
}