Tastenkombinationen für Visual Studio Code

Visual Studio Code ermöglicht es Ihnen, die meisten Aufgaben direkt über die Tastatur auszuführen. Dieser Artikel erklärt, wie Sie die Standard-Tastenkombinationen, die mit VS Code geliefert werden, ändern können.

Editor für Tastenkombinationen

VS Code bietet mit dem Editor für Tastenkombinationen eine reichhaltige Bearbeitungsumgebung für Tastenkombinationen. Der Editor listet alle verfügbaren Befehle mit und ohne Tastenkombinationen auf und ermöglicht es Ihnen, ihre Tastenkombinationen mithilfe der verfügbaren Aktionen zu ändern, zu entfernen oder zurückzusetzen. Um Befehle oder Tastenkombinationen zu finden, verwenden Sie das Suchfeld und geben Sie einen Befehl oder eine Tastenkombination ein, um die Liste zu filtern.

Um den Editor für Tastenkombinationen zu öffnen, wählen Sie das Menü Datei > Einstellungen > Tastenkombinationen aus, oder verwenden Sie den Befehl Einstellungen: Tastenkombinationen öffnen (⌘K ⌘S (Windows, Linux Ctrl+K Ctrl+S)) in der Befehlspalette.

Tastenkombinationen für UI-Aktionen anpassen

Um eine Tastenkombination für eine UI-Aktion anzupassen, klicken Sie mit der rechten Maustaste auf ein beliebiges Aktionselement in Ihrer Benutzeroberfläche und wählen Sie Tastenkombination konfigurieren aus. Dies öffnet den Editor für Tastenkombinationen, gefiltert auf den entsprechenden Befehl. Wenn die Aktion eine when-Klausel hat, wird diese automatisch einbezogen, wodurch es einfacher wird, Ihre Tastenkombinationen genau nach Ihren Wünschen einzurichten.

Keymap-Erweiterungen

Keymap-Erweiterungen ändern die VS Code-Tastenkombinationen, um sie an die anderer Editoren anzupassen, sodass Sie keine neuen Tastenkombinationen lernen müssen.

Wählen Sie das Menü Datei > Einstellungen > Tastenkombinationen migrieren von... aus, um eine Liste beliebter Keymap-Erweiterungen zu erhalten. Es gibt auch eine Keymaps-Kategorie von Erweiterungen im Marketplace.

Referenz zu Tastenkombinationen

Wir haben eine druckbare Version der Standard-Tastenkombinationen. Wählen Sie Hilfe > Referenz zu Tastenkombinationen, um eine komprimierte PDF-Version anzuzeigen, die zum einfachen Nachschlagen ausgedruckt werden kann.

Die folgenden Links bieten Zugriff auf die drei plattformspezifischen Versionen (US-amerikanisches Tastaturlayout)

• Windows
• macOS
• Linux

Erkennen von Konflikten bei Tastenkombinationen

Wenn Sie viele Erweiterungen installiert haben oder Ihre Tastenkombinationen geändert haben, kann es zu Konflikten bei Tastenkombinationen kommen, bei denen dieselbe Tastenkombination mehreren Befehlen zugeordnet ist. Dies kann zu verwirrendem Verhalten führen, insbesondere wenn verschiedene Tastenkombinationen im Bereich ein- und ausgehen, während Sie sich im Editor bewegen.

Klicken Sie mit der rechten Maustaste auf ein Element in der Liste der Tastenkombinationen und wählen Sie Gleiche Tastenkombinationen anzeigen aus, um alle Einträge mit derselben Tastenkombination anzuzeigen.

Problembehandlung für Tastenkombinationen

Um Probleme mit Tastenkombinationen zu beheben, können Sie den Befehl Entwickler: Tastenkombinations-Fehlerbehebung umschalten ausführen. Dies aktiviert die Protokollierung von verteilten Tastenkombinationen und öffnet das Ausgabefenster mit der entsprechenden Protokolldatei.

Sie können dann Ihre gewünschte Tastenkombination drücken und überprüfen, welche Tastenkombination VS Code erkennt und welcher Befehl aufgerufen wird.

Wenn Sie beispielsweise unter macOS in einem Code-Editor cmd+/ drücken, würde die Protokollausgabe wie folgt aussehen:

[KeybindingService]: / Received  keydown event - modifiers: [meta], code: MetaLeft, keyCode: 91, key: Meta
[KeybindingService]: | Converted keydown event - modifiers: [meta], code: MetaLeft, keyCode: 57 ('Meta')
[KeybindingService]: \ Keyboard event cannot be dispatched.
[KeybindingService]: / Received  keydown event - modifiers: [meta], code: Slash, keyCode: 191, key: /
[KeybindingService]: | Converted keydown event - modifiers: [meta], code: Slash, keyCode: 85 ('/')
[KeybindingService]: | Resolving meta+[Slash]
[KeybindingService]: \ From 2 keybinding entries, matched editor.action.commentLine, when: editorTextFocus && !editorReadonly, source: built-in.

Im Beispielprotokoll ist das erste Keydown-Ereignis für die Taste MetaLeft (cmd) und kann nicht verteilt werden. Das zweite Keydown-Ereignis ist für die Taste Slash (/) und wird als meta+[Slash] verteilt. Es gab zwei Tastenkombinationseinträge, die von meta+[Slash] abgebildet wurden, und der übereinstimmende war für den Befehl editor.action.commentLine, der die when-Bedingung editorTextFocus && !editorReadonly hat und ein integrierter Tastenkombinationseintrag ist.

Anzeigen geänderter Tastenkombinationen

Um die Liste so zu filtern, dass nur Ihre geänderten Tastenkombinationen angezeigt werden, wählen Sie den Befehl Benutzereigene Tastenkombinationen anzeigen im Menü Weitere Aktionen (...) aus. Dies wendet den Filter @source:user auf den Editor für Tastenkombinationen an (Quelle ist 'Benutzer').

Erweiterte Anpassung

VS Code verfolgt die von Ihnen angepassten Tastenkombinationen in der Datei keybindings.json. Für erweiterte Anpassungen können Sie auch die Datei keybindings.json direkt bearbeiten.

Zum Öffnen der Datei keybindings.json

• Öffnen Sie den Editor für Tastenkombinationen und wählen Sie dann die Schaltfläche Tastenkombinationen öffnen (JSON) rechts in der Titelleiste des Editors aus.

  

• Alternativ können Sie den Befehl Standard-Tastenkombinationen öffnen (JSON) in der Befehlspalette verwenden (⇧⌘P (Windows, Linux Ctrl+Shift+P)).

Tastenkombinationsregeln

Eine Tastenkombinationskonfiguration in VS Code wird auch als Tastenkombinationsregel bezeichnet. Jede Regel besteht aus den folgenden Attributen:

• key: beschreibt die gedrückte(n) Taste(n), z. B. ⌘F (Windows, Linux Ctrl+F).
• command: die Kennung des auszuführenden VS Code-Befehls, z. B. workbench.view.explorer zum Öffnen der Explorer-Ansicht.
• when: (optional) eine Klausel, die einen booleschen Ausdruck enthält, der je nach aktuellem Kontext ausgewertet wird.

Akkorde (zwei separate Tastendrücke) werden durch Trennen der beiden Tastendrücke mit einem Leerzeichen beschrieben. Zum Beispiel Ctrl+K Ctrl+C.

Wenn eine Taste gedrückt wird, werden die folgenden Bewertungsregeln angewendet:

• Regeln werden von unten nach oben ausgewertet.
• Die erste Regel, die sowohl der key als auch der when-Klausel entspricht, wird akzeptiert.
• Wenn eine Regel gefunden wird, werden keine weiteren Regeln verarbeitet.
• Wenn eine Regel gefunden wird und ein command festgelegt ist, wird der command ausgeführt.

Die zusätzlichen keybindings.json-Regeln werden zur Laufzeit am Ende der Standardregeln angehängt, wodurch sie die Standardregeln überschreiben können. Die Datei keybindings.json wird von VS Code überwacht, sodass das Bearbeiten während der Ausführung von VS Code die Regeln zur Laufzeit aktualisiert.

Die Verteilung von Tastenkombinationen erfolgt durch die Analyse einer Liste von Regeln, die in JSON ausgedrückt werden. Hier sind einige Beispiele:

// Keyboard shortcuts that are active when the focus is in the editor
{ "key": "home",            "command": "cursorHome",                  "when": "editorTextFocus" },
{ "key": "shift+home",      "command": "cursorHomeSelect",            "when": "editorTextFocus" },

// Keyboard shortcuts that are complementary
{ "key": "f5",              "command": "workbench.action.debug.continue", "when": "inDebugMode" },
{ "key": "f5",              "command": "workbench.action.debug.start",    "when": "!inDebugMode" },

// Global keyboard shortcuts
{ "key": "ctrl+f",          "command": "actions.find" },
{ "key": "alt+left",        "command": "workbench.action.navigateBack" },
{ "key": "alt+right",       "command": "workbench.action.navigateForward" },

// Global keyboard shortcuts using chords (two separate keypress actions)
{ "key": "ctrl+k enter",    "command": "workbench.action.keepEditor" },
{ "key": "ctrl+k ctrl+w",   "command": "workbench.action.closeAllEditors" },

Akzeptierte Tasten

Der key besteht aus Modifikatoren und der Taste selbst.

Die folgenden Modifikatoren werden akzeptiert:

Die folgenden Tasten werden akzeptiert:

• f1-f19, a-z, 0-9
• `, -, =, [, ], \, ;, ', ,, ., /
• left, up, right, down, pageup, pagedown, end, home
• tab, enter, escape, space, backspace, delete
• pausebreak, capslock, insert
• numpad0-numpad9, numpad_multiply, numpad_add, numpad_separator
• numpad_subtract, numpad_decimal, numpad_divide

Befehlsargumente

Sie können einen Befehl mit Argumenten aufrufen. Dies ist nützlich, wenn Sie häufig dieselbe Operation für eine bestimmte Datei oder einen bestimmten Ordner ausführen. Sie können eine benutzerdefinierte Tastenkombination hinzufügen, um genau das zu tun, was Sie möchten.

Das Folgende ist ein Beispiel, das die Enter-Taste überschreibt, um Text zu drucken:

{
  "key": "enter",
  "command": "type",
  "args": { "text": "Hello World" },
  "when": "editorTextFocus"
}

Der Befehl type erhält {"text": "Hello World"} als erstes Argument und fügt "Hello World" in die Datei ein, anstatt den Standardbefehl auszuführen.

Weitere Informationen zu Befehlen, die Argumente entgegennehmen, finden Sie unter Integrierte Befehle.

Ausführen mehrerer Befehle

Eine Tastenkombination kann konfiguriert werden, um mehrere Befehle nacheinander auszuführen, indem der Befehl runCommands verwendet wird.

• Mehrere Befehle ohne Argumente ausführen

  Das folgende Beispiel kopiert die aktuelle Zeile nach unten, markiert die aktuelle Zeile als Kommentar und verschiebt den Cursor zur kopierten Zeile.

  {
    "key": "ctrl+alt+c",
    "command": "runCommands",
    "args": {
      "commands": [
        "editor.action.copyLinesDownAction",
        "cursorUp",
        "editor.action.addCommentLine",
        "cursorDown"
      ]
    }
  },
  

• Argumente an Befehle übergeben

  Dieses Beispiel erstellt eine neue, unbenannte TypeScript-Datei und fügt einen benutzerdefinierten Snippet ein.

  {
    "key": "ctrl+n",
    "command": "runCommands",
    "args": {
      "commands": [
        {
          "command": "workbench.action.files.newUntitledFile",
          "args": {
            "languageId": "typescript"
          }
        },
        {
          "command": "editor.action.insertSnippet",
          "args": {
            "langId": "typescript",
            "snippet": "class ${1:ClassName} {\n\tconstructor() {\n\t\t$0\n\t}\n}"
          }
        }
      ]
    }
  },
  

Beachten Sie, dass Befehle, die von runCommands ausgeführt werden, den Wert von "args" als erstes Argument erhalten. Im vorherigen Beispiel erhält workbench.action.files.newUntitledFile {"languageId": "typescript" } als erstes und einziges Argument.

Um mehrere Argumente zu übergeben, benötigen Sie "args" als Array.

{
  "key": "ctrl+shift+e",
  "command": "runCommands",
  "args": {
    "commands": [
      {
        // command invoked with 2 arguments: vscode.executeCommand("myCommand", "arg1", "arg2")
        "command": "myCommand",
        "args": ["arg1", "arg2"]
      }
    ]
  }
}

Um ein Array als erstes Argument zu übergeben, umschließen Sie das Array in einem weiteren Array: "args": [ [1, 2, 3] ].

Entfernen einer Tastenkombination

Um eine Tastenkombination zu entfernen, klicken Sie mit der rechten Maustaste auf den Eintrag im Editor für Tastenkombinationen und wählen Sie Tastenkombination entfernen.

Um eine Tastenkombination über die Datei keybindings.json zu entfernen, fügen Sie ein - zum command hinzu, und die Regel wird zu einer Entfernungsregel.

Hier ist ein Beispiel:

// In Default Keyboard Shortcuts
...
{ "key": "tab", "command": "tab", "when": ... },
{ "key": "tab", "command": "jumpToNextSnippetPlaceholder", "when": ... },
{ "key": "tab", "command": "acceptSelectedSuggestion", "when": ... },
...

// To remove the second rule, for example, add in keybindings.json:
{ "key": "tab", "command": "-jumpToNextSnippetPlaceholder" }

Um eine bestimmte Tastenkombinationsregel mit einer leeren Aktion zu überschreiben, können Sie einen leeren Befehl angeben:

// To override and disable any `tab` keyboard shortcut, for example, add in keybindings.json:
{ "key": "tab", "command": "" }

Tastaturlayouts

Tasten sind Zeichenkettenrepräsentationen für virtuelle Tasten und beziehen sich nicht unbedingt auf das erzeugte Zeichen, wenn sie gedrückt werden. Genauer gesagt:

• Referenz: Virtuelle Schlüsselcodes (Windows)
• tab für VK_TAB (0x09)
• ; für VK_OEM_1 (0xBA)
• = für VK_OEM_PLUS (0xBB)
• , für VK_OEM_COMMA (0xBC)
• - für VK_OEM_MINUS (0xBD)
• . für VK_OEM_PERIOD (0xBE)
• / für VK_OEM_2 (0xBF)
• ` für VK_OEM_3 (0xC0)
• [ für VK_OEM_4 (0xDB)
• \ für VK_OEM_5 (0xDC)
• ] für VK_OEM_6 (0xDD)
• ' für VK_OEM_7 (0xDE)
• usw.

Unterschiedliche Tastaturlayouts verschieben diese virtuellen Tasten normalerweise oder ändern die Zeichen, die beim Drücken erzeugt werden. Bei Verwendung eines anderen Tastaturlayouts als des Standard-US-Layouts verhält sich Visual Studio Code wie folgt:

Alle Tastenkombinationen werden in der Benutzeroberfläche mit dem Tastaturlayout des aktuellen Systems gerendert. Zum Beispiel wird Split Editor bei Verwendung eines französischen Tastaturlayouts (Frankreich) jetzt als Ctrl+* gerendert.

Beim Bearbeiten von keybindings.json hebt VS Code irreführende Tastenkombinationen hervor, d. h. solche, die in der Datei mit dem Zeichen dargestellt werden, das unter dem Standard-US-Tastaturlayout erzeugt wird, aber Tasten mit anderen Bezeichnungen unter dem Tastaturlayout des aktuellen Systems erfordern. Zum Beispiel sehen die Standardregeln für Tastenkombinationen bei Verwendung eines französischen Tastaturlayouts (Frankreich) wie folgt aus:

Es gibt auch ein UI-Steuerelement, das die Eingabe der Tastenkombinationsregel beim Bearbeiten von keybindings.json erleichtert. Um das Steuerelement Tastenkombination definieren zu starten, drücken Sie ⌘K ⌘K (Windows, Linux Ctrl+K Ctrl+K). Das Steuerelement lauscht auf Tastendrücke und rendert die serialisierte JSON-Darstellung in der Textbox und darunter die Tasten, die VS Code unter Ihrem aktuellen Tastaturlayout erkannt hat. Sobald Sie die gewünschte Tastenkombination eingegeben haben, können Sie Enter drücken und ein Regel-Snippet wird eingefügt.

Layoutunabhängige Tastenkombinationen

Mithilfe von Scan-Codes ist es möglich, Tastenkombinationen zu definieren, die sich bei Änderung des Tastaturlayouts nicht ändern. Zum Beispiel:

{ "key": "cmd+[Slash]", "command": "editor.action.commentLine", "when": "editorTextFocus" }

Akzeptierte Scan-Codes

• [F1]-[F19], [KeyA]-[KeyZ], [Digit0]-[Digit9]
• [Backquote], [Minus], [Equal], [BracketLeft], [BracketRight], [Backslash], [Semicolon], [Quote], [Comma], [Period], [Slash]
• [ArrowLeft], [ArrowUp], [ArrowRight], [ArrowDown], [PageUp], [PageDown], [End], [Home]
• [Tab], [Enter], [Escape], [Space], [Backspace], [Delete]
• [Pause], [CapsLock], [Insert]
• [Numpad0]-[Numpad9], [NumpadMultiply], [NumpadAdd], [NumpadComma]
• [NumpadSubtract], [NumpadDecimal], [NumpadDivide]

when-Klausel-Kontexte

VS Code gibt Ihnen durch die optionale when-Klausel präzise Kontrolle darüber, wann Ihre Tastenkombinationen aktiviert sind. Wenn Ihre Tastenkombination keine when-Klausel hat, ist die Tastenkombination jederzeit global verfügbar. Eine when-Klausel wird entweder zu true oder false ausgewertet, um Tastenkombinationen zu aktivieren.

VS Code setzt verschiedene Kontextschlüssel und spezifische Werte, abhängig davon, welche Elemente in der VS Code-Benutzeroberfläche sichtbar und aktiv sind. Zum Beispiel hat der integrierte Befehl Debuggen starten die Tastenkombination F5, die nur aktiviert ist, wenn ein geeigneter Debugger verfügbar ist (Kontext debuggersAvailable ist true) und der Editor sich nicht im Debug-Modus befindet (Kontext inDebugMode ist false).

Sie können die when-Klausel einer Tastenkombination auch direkt in der Standard-keybinding.json einsehen (Einstellungen: Standard-Tastenkombinationen öffnen (JSON)).

{ "key": "f5",  "command": "workbench.action.debug.start",
                   "when": "debuggersAvailable && !inDebugMode" },

Bedingte Operatoren

Für bedingte Ausdrücke in der when-Klausel sind die folgenden bedingten Operatoren für Tastenkombinationen nützlich:

Die vollständige Liste der bedingten Operatoren für die when-Klausel finden Sie in der Referenz für when-Klausel-Kontexte.

Verfügbare Kontexte

Einige der verfügbaren Kontexte für die when-Klausel finden Sie in der Referenz für when-Klausel-Kontexte.

Die dortige Liste ist nicht vollständig, und Sie können weitere when-Klausel-Kontexte finden, indem Sie im Editor für Tastenkombinationen (Einstellungen: Tastenkombinationen öffnen) suchen und filtern oder die Standard-keybindings.json-Datei überprüfen (Einstellungen: Standard-Tastenkombinationen öffnen (JSON)).

Benutzerdefinierte Tastenkombinationen für Refactorings

Der Befehl editor.action.codeAction ermöglicht es Ihnen, Tastenkombinationen für spezifische Refactorings (Code Actions) zu konfigurieren. Zum Beispiel löst die folgende Tastenkombination die Code Action Funktion extrahieren aus:

{
  "key": "ctrl+shift+r ctrl+e",
  "command": "editor.action.codeAction",
  "args": {
    "kind": "refactor.extract.function"
  }
}

Dies wird im Artikel Refactoring ausführlich behandelt, wo Sie mehr über verschiedene Arten von Code Actions und deren Priorisierung bei mehreren möglichen Refactorings erfahren können.

Verwandte Ressourcen

• Referenz zu den Standard-Tastenkombinationen von VS Code

Häufig gestellte Fragen

Wie finde ich heraus, welcher Befehl an eine bestimmte Taste gebunden ist?

Im Editor für Tastenkombinationen können Sie nach spezifischen Tastendrücken filtern, um zu sehen, welche Befehle an welche Tasten gebunden sind. Im folgenden Screenshot sehen Sie, dass Ctrl+Shift+P an Alle Befehle anzeigen gebunden ist, um die Befehlspalette aufzurufen.

Wie füge ich einer Aktion eine Tastenkombination hinzu, z. B. Ctrl+D zum Löschen von Zeilen?

Finden Sie eine Regel, die die Aktion auslöst, in den Standard-Tastenkombinationen und schreiben Sie eine modifizierte Version davon in Ihrer Datei keybindings.json.

// Original, in Default Keyboard Shortcuts
{ "key": "ctrl+shift+k",          "command": "editor.action.deleteLines",
                                     "when": "editorTextFocus" },
// Modified, in User/keybindings.json, Ctrl+D now will also trigger this action
{ "key": "ctrl+d",                "command": "editor.action.deleteLines",
                                     "when": "editorTextFocus" },

Wie kann ich eine Tastenkombination nur für bestimmte Dateitypen hinzufügen?

Verwenden Sie den Kontextschlüssel editorLangId in Ihrer when-Klausel.

{ "key": "shift+alt+a",           "command": "editor.action.blockComment",
                                     "when": "editorTextFocus && editorLangId == csharp" },

Ich habe meine Tastenkombinationen in keybindings.json geändert; warum funktionieren sie nicht?

Das häufigste Problem ist ein Syntaxfehler in der Datei. Andernfalls versuchen Sie, die when-Klausel zu entfernen oder eine andere key zu wählen. Leider ist es zu diesem Zeitpunkt ein Prozess des Ausprobierens.