Register

Was ein Register ist

Ein Register ist intern ein einzelner Lisp-Slot, der durch einen Buchstaben benannt ist. Alle Register-Befehle teilen sich das gemeinsame Prefix C-x r — es wurde in dieser Doku bereits für Rectangles eingeführt und ist tatsächlich der ältere, ursprüngliche Heimathafen: das r stand zuerst für „register". Auf das Prefix folgen zwei Dinge: ein Verb-Buchstabe (welche Art von Inhalt? SPC für Position, s für Text, w für Window-Config …) und ein Register-Buchstabe (welcher Slot? a, b, c …).

Drei Eigenschaften, die Register von anderen Wiederverwendungs-Mechanismen abgrenzen:

• Direkt addressierbar. Anders als der Kill-Ring (LIFO-Liste, die man rückwärts durchcyclen muss) ist ein Register direkt per Buchstabe ansprechbar. „Spring zu Register a" ist eine deterministische Operation.
• Buffer-übergreifend. Register leben global in der Emacs-Instanz. Ein Position-Register, das du in Buffer A setzt, springt von jedem anderen Buffer aus zurück nach A.
• Polymorph. Ein und derselbe Slot kann je nach Befehl eine Position, einen Text, eine Window-Config oder eine Zahl enthalten. Der Abruf-Befehl entscheidet aus dem gespeicherten Typ heraus, was passieren soll.

Auffällig: C-x r j ist der eine Sprung-Befehl für alle „strukturellen" Inhalte (Position, Window-Config, Frame-Config), und C-x r i ist der eine Einfüge-Befehl für alle „textuellen" Inhalte (Text, Rectangle, Zahl). Emacs schaut beim Aufruf in den Slot und macht das, was zum Typ passt.

Position-Register: C-x r SPC

Der häufigste Einstieg in Register ist das Speichern einer Position. Eine Position ist mehr als nur die Zeilen-/Spalten-Nummer: gespeichert wird (Buffer, Punkt-Position) als Paar. Der Sprung zurück wechselt also bei Bedarf automatisch den Buffer.

• C-x r SPC a — point-to-register — speichert die aktuelle Position im Register a.
• C-x r j a — jump-to-register — springt zur gespeicherten Position (ggf. mit Buffer-Wechsel).

Per Befehlsnamen aufrufbar über M-x point-to-register bzw. M-x jump-to-register. Beide fragen anschließend im Minibuffer nach dem Register-Buchstaben — die Tastenfolge C-x r SPC a und der dialogische Weg führen also zum exakt selben Ergebnis.

Der typische Pendel-Workflow zwischen zwei Edit-Stellen sieht so aus:

Schritt 1: Cursor an Stelle 1   →  C-x r SPC a
Schritt 2: Cursor an Stelle 2   →  C-x r SPC b
Schritt 3: zurück zu Stelle 1   →  C-x r j a
Schritt 4: wieder zu Stelle 2   →  C-x r j b
Schritt 5: beliebig oft hin und her

Anders als bei set-mark und dem Mark-Ring brauchst du dir nicht zu merken, wie oft du schon zurück-cyclen musst — der Buchstabe a ist und bleibt Stelle 1, der Buchstabe b ist und bleibt Stelle 2. Das Mark-Ring-Verhalten („letzte gesetzte Marke") ist flüchtig und konkurriert mit jeder anderen Aktion, die Mark setzt; Register-Positionen sind explizit und stabil.

Eine Feinheit: Position-Register überleben das Schließen eines Buffers nicht sauber. Wird der Buffer, in dem die Position liegt, gekillt, meldet jump-to-register That register doesn't contain a buffer or file. Soll der Sprung-Punkt auch nach Buffer-Kill funktionieren, hilft bookmark-set (C-x r m) — Bookmarks speichern den Datei-Pfad und können die Datei neu öffnen.

Text-Register: C-x r s und C-x r i

Soll nicht eine Position, sondern der Text einer Region in einem Register landen, ist der Befehl copy-to-register. Voraussetzung: eine aktive Region (Mark gesetzt, Punkt am Region-Ende).

• C-x r s a — copy-to-register — kopiert die Region in Register a.
• C-x r i a — insert-register — fügt den Inhalt von Register a an Point ein.

Beide kennen zwei Prefix-Argument-Varianten, die das Verhalten umschalten:

Praktischer als der Kill-Ring ist copy-to-register immer dann, wenn ein Snippet diese Session mehrfach gebraucht wird, sich aber nicht im Ring nach hinten schieben soll, sobald du zwischendurch etwas anderes killst. Beispiel: du editierst eine längere Datei, brauchst zwischendurch immer wieder denselben Boilerplate-Block für Logger-Aufrufe. Ein einmaliges C-x r s l (l für „Logger") legt den Block in den Slot — egal, was du danach kopierst oder killst, mit C-x r i l ist er immer wieder verfügbar.

Zwei verwandte Befehle, die kein eigenes Tasten-Binding haben, aber per M-x nützlich sind:

• M-x append-to-register — hängt die aktive Region an den bestehenden Inhalt des Registers an. Mit C-u zusätzlich die Region im Buffer löschen.
• M-x prepend-to-register — fügt die Region VOR den bestehenden Register-Inhalt. Prefix-Verhalten analog.

Das Trennzeichen zwischen den Fragmenten steuert die Variable register-separator — wer Fragmente etwa durch eine Leerzeile getrennt sammeln will, kann das so vorgeben:

;; Wenn vorhanden, wird der Inhalt von Register S beim Append/Prepend
;; als Trenner zwischen den Fragmenten verwendet.
(set-register ?S "\n\n")
(setq register-separator ?S)

Wohin dieser Code gehört, klärt der Artikel zur Konfiguration mit init.el und early-init.el.

Window-Configurations

Eine Window-Configuration ist die komplette Anordnung der Fenster innerhalb des aktuellen Frames: welche Buffer wo angezeigt werden, in welcher Aufteilung, mit welchen Größen. Genau diese Anordnung lässt sich in einem Register ablegen — und mit demselben Sprung-Befehl, der auch für Positionen genutzt wird, wiederherstellen.

• C-x r w a — window-configuration-to-register — aktuelle Window-Anordnung in Register a speichern.
• C-x r j a — jump-to-register (identischer Befehl wie für Positionen) — Window-Anordnung wiederherstellen.

Der eine j-Befehl erkennt am Inhalt des Registers, was zu tun ist: liegt eine Position drin, springt er; liegt eine Window-Config drin, restauriert er das Layout; liegt eine Frame-Config drin, restauriert er sogar die Frame-Anordnung. Polymorphie nach Inhaltstyp.

Der häufigste Use-Case ist „Layout sichern vor dem Experiment": vor einem Refactoring, einer Compile-Session oder einem Debug-Lauf wird das funktionierende Layout per C-x r w a gesichert. Splittest du danach beliebig viel um, öffnest Hilfs-Buffer, schließt Fenster — ein einziges C-x r j a ist der Reset auf den Ausgangszustand.

+-----------------+-----------+
| main.go         | repl      |       Ausgangs-Layout
|                 |           |       (3-fach Split)
+-----------------+-----------+
| *Messages*                  |
+-----------------------------+

        ↓  C-x r w a   (sichern in Register a)

... viele Splits, Helper-Buffer, Hilfe-Fenster, *grep* ...

        ↓  C-x r j a   (zurück zum gespeicherten Layout)

+-----------------+-----------+
| main.go         | repl      |       wiederhergestellt
|                 |           |
+-----------------+-----------+
| *Messages*                  |
+-----------------------------+

Eine sinnvolle Ergänzung ist winner-mode — siehe Winner-Mode und windmove. winner arbeitet History-basiert (Undo/Redo für Fenster-Änderungen), Register-Layouts arbeiten benannt. In der Praxis ergänzen sich beide gut: winner für „einen Schritt zurück", Register für „zurück zu meinem gesunden Layout, egal wie tief ich gerade drin bin".

Frame-Configurations und Zahlen-Register

Zwei weniger genutzte, aber existierende Register-Arten runden das Bild ab.

Frame-Configurations

• C-x r f a — frame-configuration-to-register — speichert ALLE offenen Frames inklusive ihrer Größen, Positionen, Fenster-Splits.
• C-x r j a — derselbe Sprung-Befehl restauriert die komplette Multi-Frame-Anordnung.

Interessant für Multi-Monitor-Setups oder Daemon-Sessions mit mehreren Frames: ein einziger Befehl bringt die gesamte Arbeitsumgebung in einen definierten Zustand zurück. Im Alltag eher Nische; wer aber regelmäßig zwischen „2 Frames für Code" und „1 Frame für Schreiben" pendelt, hat hier einen sauberen Schalter.

Zahlen-Register

Register können auch Zahlen enthalten — gemeinsam mit Keyboard-Makros (siehe Keyboard-Macros) sind sie ein einfacher Mechanismus für Counter und Schleifen.

• C-u 42 C-x r n a — number-to-register mit Prefix-Argument 42 — speichert die Zahl 42 im Register a.
• C-x r + a — increment-register — erhöht die Zahl im Register a um 1; auf Text-Registern hängt der Befehl statt zu inkrementieren die Region an den bestehenden Text an.
• C-x r i a — insert-register — fügt die Zahl als Dezimal-String an Point ein.

Der Klassiker dazu ist „nummerierte Listen per Makro": Counter mit C-u 1 C-x r n a auf 1 setzen, dann im Makro pro Iteration einmal C-x r i a einfügen und mit C-x r + a erhöhen. Das Makro produziert beim Abspielen 1, 2, 3, … ohne Suchen-Ersetzen-Tricks.

Vorbereitung:
  C-u 1 C-x r n a       Register a := 1

Makro definieren (F3 startet Aufnahme, F4 beendet sie):
  F3
    C-x r i a           Zahl einfügen
    C-x r + a           Zahl erhöhen
    TAB ". Eintrag"     Text dahinter
    RET                 Zeile beenden
  F4

Mit F4 abspielen oder C-u 10 F4 für zehn Wiederholungen.

Ergebnis:
  1. Eintrag
  2. Eintrag
  3. Eintrag
  ...

Alle Register anzeigen

Register sind ohne Hilfsmittel unsichtbar — der Buchstabe alleine sagt nichts darüber, was im Slot liegt. Zwei eingebaute Wege schaffen Übersicht.

• M-x list-registers — öffnet einen *Register List*-Buffer mit allen aktuell belegten Registern. Jede Zeile zeigt den Buchstaben, den Typ und einen Vorschau-Auszug des Inhalts.
• M-x view-register — fragt nach einem einzelnen Register-Buchstaben und zeigt dessen Inhalt im Echo-Area bzw. in einem temporären Buffer (für längere Texte).

Im *Register List*-Buffer sind die wichtigen Tasten:

Wer keine Liste braucht, sondern nur „kurz reingucken, was in a liegt", nutzt M-x view-register mit a als Argument. Beide Befehle sind Pflichtwissen — ohne sie verliert man nach 10–15 belegten Registern schnell die Übersicht über die Buchstaben-Zuordnung.

Praktische Workflows

Fünf konkrete Muster, die Register im Alltag tragen:

Zwischen zwei Edit-Stellen pendeln

Cursor an Stelle 1 → C-x r SPC a. Cursor an Stelle 2 → C-x r SPC b. Ab jetzt bringen dich C-x r j a und C-x r j b direkt zwischen beiden hin und her — auch über Buffer-Grenzen hinweg. Funktioniert auch für drei oder vier Stellen (c, d, …); die Buchstaben kannst du frei wählen.

Snippet für die Session

Region markieren → C-x r s s (Register „s" für Snippet). Mit C-x r i s beliebig oft einfügen, in jedem Buffer, in beliebiger Reihenfolge. Sobald du den Snippet nicht mehr brauchst, lass ihn einfach liegen — er belegt nur ein Byte Speicher.

Layout sichern vor Experiment

Bevor du das laufende Refactoring oder Debug-Setup mit neuen Splits durcheinanderbringst: C-x r w a (Layout-Register „a"). Splittest, schließt, öffnest Hilfe-Buffer, grep, Help, Messages. Wenn das Layout kaputt ist: C-x r j a bringt alles zurück.

Counter im Keyboard-Macro

C-u 1 C-x r n a setzt Register a auf 1. Im Makro: C-x r i a fügt die Zahl ein, C-x r + a inkrementiert. Beim Abspielen produziert das Makro fortlaufende Nummern — ohne dass du eine Schleife schreiben müsstest.

Wo war ich gestern?

Register überleben die laufende Emacs-Session, aber nicht den Emacs-Restart. Wenn du eine Position auch über Tage halten willst, sind Bookmarks das richtige Werkzeug — sie persistieren in ~/.emacs.d/bookmarks und können sogar Dateien neu öffnen, die zwischenzeitlich geschlossen wurden. Details im Artikel Bookmarks. Bookmark setzen: C-x r m — übrigens auch unter dem C-x r-Prefix, weil Bookmarks im selben System wohnen.

Weiterführende Ressourcen

Externe Quellen

• GNU Emacs Manual — Registers — offizielle Übersicht aller Register-Arten und des C-x r-Prefix.
• GNU Emacs Manual — Position Registers — point-to-register, jump-to-register im Detail.
• GNU Emacs Manual — Text Registers — copy-to-register, insert-register, append-to-register, prepend-to-register inklusive Prefix-Verhalten.
• GNU Emacs Manual — Configuration Registers — Window- und Frame-Configurations.
• GNU Emacs Manual — Number Registers — number-to-register und increment-register.

Verwandte Artikel

• Kill und Yank — das Konzept
• Rectangles
• Keyboard-Macros
• Winner-Mode und windmove
• Bookmarks
• YASnippet
• Konfiguration mit init.el und early-init.el