---
title: "Códigos das teclas de letras: A–Z keyCode 65–90, event.key, event.code"
description: "As letras enviam keyCode 65 a 90, event.code \"KeyA\" a \"KeyZ\" e event.key \"a\" ou \"A\". Veja quando usar key ou code, para atalhos e WASD funcionarem em qualquer layout."
url: https://devicetests.com/pt-br/keycode/letter-keys
language: pt-BR
---

# Códigos das teclas de letras (A–Z)

As teclas de letras enviam event.code "KeyA" a "KeyZ", event.key "a" a "z" em um layout US ("A" a "Z" com Shift ou Caps Lock) e keyCode 65 a 90.

## Todos os valores de relance

| Tecla | event.code | event.key | keyCode | event.location |
| - | - | - | - | - |
| A | `KeyA` | `a` | 65 | 0 (Padrão) |
| B | `KeyB` | `b` | 66 | 0 (Padrão) |
| C | `KeyC` | `c` | 67 | 0 (Padrão) |
| D | `KeyD` | `d` | 68 | 0 (Padrão) |
| E | `KeyE` | `e` | 69 | 0 (Padrão) |
| F | `KeyF` | `f` | 70 | 0 (Padrão) |
| G | `KeyG` | `g` | 71 | 0 (Padrão) |
| H | `KeyH` | `h` | 72 | 0 (Padrão) |
| I | `KeyI` | `i` | 73 | 0 (Padrão) |
| J | `KeyJ` | `j` | 74 | 0 (Padrão) |
| K | `KeyK` | `k` | 75 | 0 (Padrão) |
| L | `KeyL` | `l` | 76 | 0 (Padrão) |
| M | `KeyM` | `m` | 77 | 0 (Padrão) |
| N | `KeyN` | `n` | 78 | 0 (Padrão) |
| O | `KeyO` | `o` | 79 | 0 (Padrão) |
| P | `KeyP` | `p` | 80 | 0 (Padrão) |
| Q | `KeyQ` | `q` | 81 | 0 (Padrão) |
| R | `KeyR` | `r` | 82 | 0 (Padrão) |
| S | `KeyS` | `s` | 83 | 0 (Padrão) |
| T | `KeyT` | `t` | 84 | 0 (Padrão) |
| U | `KeyU` | `u` | 85 | 0 (Padrão) |
| V | `KeyV` | `v` | 86 | 0 (Padrão) |
| W | `KeyW` | `w` | 87 | 0 (Padrão) |
| X | `KeyX` | `x` | 88 | 0 (Padrão) |
| Y | `KeyY` | `y` | 89 | 0 (Padrão) |
| Z | `KeyZ` | `z` | 90 | 0 (Padrão) |

keyCode como o Chrome e o Edge enviam no Windows. A coluna do Mac (Chrome e Safari no Mac) e a do Firefox mostram só os números diferentes; algumas teclas também mudam conforme o sistema, como diz o texto abaixo. event.which é sempre o mesmo número do keyCode. event.key vale para um layout dos EUA sem Shift.

## Código para reagir a A

Recomendado: identificar por event.key

```
document.addEventListener('keydown', (event) => {
  if (event.key === 'a') {
    // Seu código aqui
  }
});
```

Identificar pelo lugar da tecla: event.code

```
document.addEventListener('keydown', (event) => {
  if (event.code === 'KeyA') {
    // Seu código aqui
  }
});
```

Código antigo que ainda usa keyCode (obsoleto)

```
document.addEventListener('keydown', (event) => {
  if (event.keyCode === 65) {
    // Seu código aqui
  }
});
```

## Qual valor usar

Depende do que importa: a letra ou o lugar da tecla no teclado.

Para letras digitadas e atalhos com nome de letra, como Ctrl + Z para desfazer, verifique `event.key`. Ele segue o layout do usuário, então o atalho funciona na tecla que mostra um Z.

Para teclas escolhidas pelo lugar, como WASD em um jogo, verifique `event.code`. `KeyW` é a tecla acima do S em qualquer layout, até em um teclado francês AZERTY, onde ela digita “z”.

`keyCode` é o número da letra maiúscula: 65 para A até 90 para Z, com ou sem Shift. Em layouts latinos, ele costuma seguir a letra digitada. No AZERTY, a tecla com código `KeyQ` digita “a” e envia 65. Em layouts russo, grego e outros não latinos, costuma ser a letra US daquele lugar.

## O que costuma dar errado

### event.key é “A” em vez de “a”

Shift e Caps Lock mudam o `event.key`. Compare em minúsculas, `event.key.toLowerCase() === 'a'`, e verifique `event.shiftKey` à parte se o Shift importar. Isso também ajuda no Mac, onde Cmd + Shift + Z pode chegar como um “z” minúsculo.

### Os controles WASD não funcionam em um teclado francês

Se você verifica `event.key === 'w'`, jogadores de AZERTY precisam alcançar o W no canto inferior esquerdo. Verifique `event.code` (`KeyW`, `KeyA`, `KeyS`, `KeyD`) para as teclas ficarem no mesmo lugar. Para mostrar as letras certas no texto de ajuda, o Chrome e o Edge informam o que um código digita: `navigator.keyboard.getLayoutMap()`.

### Ctrl+Z cai na tecla errada em teclados alemães ou franceses

O QWERTZ alemão troca Z e Y, e no AZERTY o Z fica onde está o W em um teclado US. Um atalho verificado com `event.code === 'KeyZ'` faz usuários alemães apertarem a tecla marcada com Y. Compare atalhos de letra com `event.key`.

### Atalhos param de funcionar em um layout russo ou grego

Nesses layouts, `event.key` é a letra daquele alfabeto: Ctrl + Z em um layout russo envia “я”. Use o lugar da tecla quando ela não for uma letra latina:

```
const letter = /^[a-z]$/i.test(event.key)
  ? event.key.toLowerCase()
  : event.code.startsWith('Key') ? event.code.slice(3).toLowerCase() : '';
```

### Alt+letra digita um caractere no Mac

Option + S digita “ß”, então `event.key` é “ß”, e não “s”. Option + E é uma tecla morta: `event.key` é “Dead” e a próxima letra recebe o acento. Compare atalhos com Alt usando `event.code` e `event.altKey`. No Windows, layouts com AltGr fazem o mesmo com Ctrl + Alt: Ctrl + Alt + E digita € em um teclado alemão. Por isso, evite atalhos com Ctrl + Alt + letra.

## Teclas relacionadas

- [Códigos das teclas numéricas (0–9)](https://devicetests.com/pt-br/keycode/number-keys)
- [Código da tecla Shift](https://devicetests.com/pt-br/keycode/shift)
- [Código da tecla Caps Lock](https://devicetests.com/pt-br/keycode/caps-lock)
- [Código da tecla Alt](https://devicetests.com/pt-br/keycode/alt)
- [Código da tecla Control](https://devicetests.com/pt-br/keycode/control)
- [Descobrir o código de uma tecla: pressione qualquer tecla para ver os códigos](https://devicetests.com/pt-br/keycode)
- [Todos os códigos de tecla em uma tabela](https://devicetests.com/pt-br/keycode#key-codes)
