Keyboard-Macros

Aufnehmen und Abspielen

Der gesamte Macro-Workflow besteht aus drei Tasten: Aufnahme starten, Aufnahme beenden, Macro abspielen. Emacs bietet dafür je eine moderne F-Tasten-Variante und eine klassische Prefix-Variante an.

Der typische Ablauf in vier Schritten:

1. Cursor an die Stelle stellen, ab der das Macro greifen soll.
2. F3 drücken — die Modeline zeigt Defining kbd macro....
3. Die gewünschte Aktion ausführen: Tasten, Befehle, Suchen, Bewegungen — alles wird aufgezeichnet.
4. F4 beendet die Aufnahme. Ein erneutes F4 spielt das Macro ab.

Mit einem numerischen Prefix wiederholt Emacs das Macro mehrfach am Stück: C-u 10 F4 spielt das letzte Macro zehn Mal.

Hinweis zu F-Tasten auf macOS

Apple-Tastaturen belegen die F-Tasten standardmäßig mit Helligkeit, Lautstärke und Mission-Control. Damit F3/F4 in Emacs greifen, gibt es zwei Wege:

• In den Systemeinstellungen unter Tastatur → „Funktionstasten F1, F2 usw. als Standard-Funktionstasten verwenden" aktivieren.
• Oder situativ mit gedrückter fn-Taste auslösen: fn+F3 bzw. fn+F4.

Wer beides nicht mag, bindet die Befehle direkt auf bequemere Tasten — das zeigt der Konfig-Block in Sektion 04.

Mehrere Wiederholungen am Stück

Macros entfalten ihre Kraft erst beim Wiederholen. Emacs kennt drei Idiome für unterschiedliche Mengen:

Das letzte Muster ist das wichtigste in der Praxis: C-u 0 C-x e spielt das Macro so lange, bis irgendein enthaltener Befehl scheitert — typischerweise „Suchen" am Buffer-Ende oder „nächste Zeile" auf der letzten Zeile. Genau das macht es zum Standard-Idiom für „wende dieses Macro auf jede Zeile bis zum Ende an".

Beispiel: Ein Macro, das C-n C-a ausführt (eine Zeile runter, an den Anfang), wird durch C-u 0 C-x e bis ans Buffer-Ende laufen. Sobald C-n am Ende kein „nächste Zeile" mehr findet, wirft es einen Fehler, der den Loop sauber stoppt.

Macro-Counter für variable Werte

Jedes Macro hat einen eingebauten Counter — eine Zahl, die du an beliebiger Stelle ins Macro einfügen kannst und die bei jedem Insert automatisch hochzählt. Damit lassen sich nummerierte Listen, fortlaufende IDs oder durchnummerierte Variablen-Namen erzeugen, ohne eine Zeile Elisp zu schreiben.

Die wichtigsten Counter-Befehle (während der Aufnahme drücken):

Beispiel: 20 nummerierte Einträge erzeugen

Cursor in eine leere Zeile setzen und folgende Aufnahme machen:

1. F3 — Aufnahme starten.
2. C-x C-k C-i — Counter einfügen (zeigt 0).
3. . tippen (Punkt und Leerzeichen).
4. Eintrag tippen.
5. RET — neue Zeile.
6. F4 — Aufnahme beenden.

Jetzt C-u 19 C-x e drücken — das Macro läuft weitere 19 Mal und erzeugt eine durchnummerierte Liste:

0. Eintrag
1. Eintrag
2. Eintrag
…
19. Eintrag

Mit C-x C-k C-f und Format-String %03d werden daraus 000, 001, 002 — praktisch für lexikalisch sortierbare Dateinamen oder Schritt-IDs.

Macros benennen und an Tasten binden

Solange ein Macro nur „das letzte" ist, geht es bei der nächsten Aufnahme verloren. Wer es behalten will, gibt ihm einen Namen — danach verhält es sich wie ein ganz normaler Emacs-Befehl: aufrufbar mit M-x, bindbar an Tasten, persistierbar in der init.el.

Benennen

Konvention: Namen mit Bindestrich, alles klein — z. B. meine-prefix-zeile oder nummerieren-bis-ende. Nach dem Benennen kannst du das Macro mit M-x meine-prefix-zeile wie jeden anderen Befehl aufrufen.

An eine Taste binden

Benannte Macros sind Funktionen — also auch an eine Tastenkombination bindbar. Der reservierte Benutzer-Bereich ist C-c + Buchstabe:

;; Benanntes Macro auf C-c m binden
(keymap-global-set "C-c m" #'meine-prefix-zeile)

Wo dieser Code hingehört

Das Snippet gehört in deine init.el (~/.emacs.d/init.el oder ~/.config/emacs/init.el). Wie diese Datei geladen wird und in welcher Reihenfolge early-init.el und init.el zum Zug kommen, beschreibt der Artikel init.el und early-init.el im Detail. Für eine schnelle Probe reicht es, den Block am Ende der init.el einzufügen, zu speichern und Emacs neu zu starten.

Macros editieren und in der init.el speichern

Manchmal merkt man erst beim ersten Abspielen, dass im Macro ein Tippfehler steckt. Statt es neu aufzuzeichnen, kann man es direkt editieren — oder gleich in die Konfiguration übernehmen.

Persistenz-Workflow

Damit ein Macro Emacs-Neustarts überlebt, geht der Weg über insert-kbd-macro:

1. Macro aufnehmen mit F3 … F4.
2. Mit C-x C-k n benennen, z. B. als meine-prefix-zeile.
3. Datei ~/.emacs.d/macros.el öffnen (oder anlegen).
4. M-x insert-kbd-macro RET meine-prefix-zeile RET — Emacs schreibt die Macro-Definition als Elisp-Block in den Buffer.
5. Datei speichern.
6. In init.el einbinden:

;; Persistierte Macros laden
(load "~/.emacs.d/macros.el")

;; Macro auf eine Taste legen
(keymap-global-set "C-c m" #'meine-prefix-zeile)

Der erzeugte Block in macros.el sieht typischerweise so aus — Emacs schreibt ihn automatisch, du musst die Tastencodes nicht selbst tippen:

(fset 'meine-prefix-zeile
      (kmacro "C-a / / SPC C-n"))

Wo dieser Code hingehört

Sowohl init.el als auch macros.el liegen im Emacs-Benutzer-Verzeichnis (~/.emacs.d/ oder ~/.config/emacs/). Details zur Lade-Reihenfolge und zur Strukturierung größerer Konfigurationen behandelt der Artikel init.el und early-init.el.

Der Macro-Ring

Emacs verwaltet nicht nur „das letzte Macro", sondern einen kompletten Ring der zuletzt aufgenommenen Macros — analog zum Kill-Ring für Text. Wer zwischen mehreren Macros pendelt, ohne sie zu benennen, nutzt den Ring direkt.

Die Ring-Größe steuert die Variable kmacro-ring-max (Default 8). Praktisches Szenario: Zwei Macros parallel — eines fügt einen Header ein, das andere räumt Whitespace auf. Statt beides zu benennen, hältst du sie im Ring und wechselst per C-x C-k C-n.

Praktische Workflows

Sieben Beispiele, wie Macros im Alltag den Unterschied machen:

Alle Zeilen mit // präfixen

Cursor an den Anfang der ersten Zeile setzen.

1. F3 — Aufnahme starten.
2. C-a — an den Zeilenanfang.
3. // tippen.
4. C-n — eine Zeile weiter.
5. F4 — Aufnahme beenden.
6. C-u 0 C-x e — bis Buffer-Ende laufen lassen.

Liste durchnummerieren

1. F3 → C-a → C-x C-k C-i (Counter) → . tippen → C-e → C-n → F4.
2. Cursor an den ersten Listeneintrag.
3. C-u 0 C-x e — jede Zeile bekommt ihre Nummer.

Tabellen-Spalten umordnen

Ein Macro, das mit Suchen (C-s) zum Trennzeichen springt, ein Feld ausschneidet und an anderer Stelle einfügt — anschließend C-u 0 C-x e über alle Zeilen. Funktioniert verlässlich, solange die Spaltenstruktur einheitlich ist.

Quick-Refactor von Property-Definitionen

In OOP-Quelltext: Macro, das den Cursor auf den Property-Namen schiebt, ihn dupliziert und mit Getter-Setter-Boilerplate umschließt. Über das ganze File angewendet, ersetzt das ein halbes IDE-Refactoring.

Persistente Daily-Workflow-Action

Einmal aufnehmen → benennen → mit insert-kbd-macro in ~/.emacs.d/macros.el schreiben → in init.el laden → an C-c m binden. Ab dem nächsten Emacs-Start dauerhaft verfügbar.

IDs mit Format-String erzeugen

Counter auf 0 setzen, Format auf ID-%04d, Macro einfügt Counter + Tab + Werte-Template. Ergebnis: ID-0000, ID-0001, ID-0002.

Macros kombinieren

Zwei Macros nacheinander definieren, beide im Ring. Erst Macro A einmal auf eine Auswahl anwenden, dann mit C-x C-k C-n zu Macro B wechseln und es auf das Ergebnis loslassen — Pipeline ohne Skripting.

Weiterführende Ressourcen

Externe Quellen

• GNU Emacs Manual — Keyboard Macros — die offizielle Kapitel-Übersicht.
• GNU Emacs Manual — Basic Keyboard Macro — Aufnahme, Abspielen, Counter im Detail.
• GNU Emacs Manual — Save Keyboard Macro — Benennen, insert-kbd-macro und Persistenz.
• GNU Emacs Manual — Keyboard Macro Ring — Macro-Ring und Cycle-Befehle.
• EmacsWiki — KeyboardMacros — Community-Tipps und Use-Cases.

Verwandte Artikel

• Register
• Region und Mark
• Rectangles
• Multiple-Cursors und iedit
• YASnippet
• init.el und early-init.el