Rectangles — Block-Editing

Was ein Rectangle ist

Ein Rectangle ist die geometrische Schnittmenge der Spalten und Zeilen zwischen Point und Mark. Die normale Region zwischen zwei Positionen umfasst alle Zeichen in der Reihenfolge des Buffers — vom Start-Offset bis zum End-Offset, inklusive Zeilenumbrüchen. Ein Rectangle ignoriert die Reihenfolge und betrachtet nur die Zeichen, die gleichzeitig im Spalten-Bereich (links/rechts) UND im Zeilen-Bereich (oben/unten) liegen.

Der Unterschied wird am ASCII-Schema sofort klar:

Buffer-Inhalt:                Mit normaler Region (linear):
  foo bar baz                   [foo bar baz
  xyz abc def     →             xyz abc d]ef
  uvw ghi jkl                   uvw ghi jkl

Mit Rectangle (Block):
  foo [bar] baz                 ← nur die Spalten 4-6
  xyz [abc] def                 ← in den drei Zeilen
  uvw [ghi] jkl                 ← werden adressiert

Konkret heißt das: Point bei foo bar baz zwischen b und a von bar, Mark bei uvw ghi jkl direkt hinter i von ghi — die normale Region zieht alle Zeichen dazwischen ein (drei Zeilen, vom ersten bar bis zum dritten ghi). Das Rectangle reduziert auf den Spalten-Bereich, den Point und Mark aufspannen, und wirkt nur dort.

Daraus folgt eine Eigenschaft, die mit linearer Region nicht möglich wäre: Operationen, die jede Zeile im Spalten-Bereich gleich behandeln — sie ausschneiden, durch Text ersetzen, durch Leerzeichen füllen, mit Whitespace nach rechts schieben oder fortlaufend nummerieren. Genau das machen die C-x r ...-Befehle.

Rectangle aktivieren

Es gibt zwei Wege, mit Rectangles zu arbeiten — und sie unterscheiden sich nur in der Visualisierung, nicht in der Logik.

Weg 1 — Mit Visualisierung (rectangle-mark-mode): aus einer aktiven Region ein Rechteck machen, das auch optisch als Rechteck hervorgehoben wird.

• C-x SPC — rectangle-mark-mode togglen
• Alternativ M-x rectangle-mark-mode

Ohne aktive Region setzt C-x SPC die Mark am aktuellen Point und aktiviert den Modus in einem Schritt. Sobald Point dann durch den Buffer wandert, wird die Hervorhebung als sauberes Rechteck mitgezeichnet — nicht als linearer Streifen wie bei der normalen Region.

Weg 2 — Ohne Visualisierung: einfach Mark setzen, Point an die gegenüberliegende Ecke navigieren und direkt einen C-x r ...-Befehl ausführen. Die Logik unter diesen Befehlen arbeitet ohnehin mit den Spalten-Grenzen von Point und Mark — rectangle-mark-mode ist also keine Voraussetzung, sondern eine optische Hilfe.

In der Praxis lohnt sich der Modus immer dann, wenn die Selektion mehrere Korrekturen braucht („eine Spalte weiter rechts beginnen, eine Zeile tiefer enden") — dann sieht man sofort, welcher Block am Ende verarbeitet wird. Für Routine-Operationen, bei denen man die Eckpunkte präzise kennt, reicht der direkte C-x r ...-Befehl ohne Modus.

Die wichtigsten Rectangle-Befehle

Alle Rectangle-Operationen liegen unter dem Prefix C-x r. Die Buchstaben danach sind weitgehend mnemonisch: k für kill, y für yank, d für delete, t für „text einsetzen" usw.

Zwei Anmerkungen zum Kill-Speicher: gekillte und kopierte Rectangles landen NICHT im normalen Kill-Ring, sondern in einer eigenen Variablen killed-rectangle. Konsequenz: C-y (das gewohnte Yank) holt sie nicht zurück — dafür gibt es ausdrücklich C-x r y. Umgekehrt holt C-x r y nur Rectangles, nie normale Kills.

Wer sich alle Varianten anschauen will: M-x apropos-command RET rectangle RET listet alle 20+ Befehle des Rectangle-Pakets — viele davon sind Edge-Cases, aber ein Durchscrollen lohnt sich einmal im Leben.

C-x r t als Killer-Feature

Der string-rectangle-Befehl ist einer der mächtigsten Refactoring-Helfer in Vanilla-Emacs — und gleichzeitig einer der am häufigsten übersehenen. Workflow:

1. Rectangle aufspannen über alle Zeilen, in denen dieselbe Spalten-Stelle geändert werden soll (z. B. die ersten vier Zeichen var am Anfang jeder Zeile).
2. C-x r t drücken.
3. Emacs fragt im Minibuffer nach dem Ersetzungs-String.
4. Eingabe abschicken mit RET.

Jede Zeile im Rectangle bekommt den Rectangle-Bereich durch den neuen String ersetzt — Zeile für Zeile, in einem einzigen Kommando.

Vorher                        Rectangle über die 4 Zeichen „var "
var foo = 1;                  [var ]foo = 1;
var bar = 2;                  [var ]bar = 2;
var baz = 3;                  [var ]baz = 3;

Nachher  (C-x r t  →  „const ")
const foo = 1;
const bar = 2;
const baz = 3;

Wichtige Eigenheit: der Befehl heißt nicht ohne Grund string-rectangle — er ersetzt den Rectangle-Inhalt, er fügt nicht zusätzlich ein. Wer nur einfügen will, ohne etwas zu überschreiben, nutzt M-x string-insert-rectangle: dort wandert der bestehende Inhalt nach rechts, statt überschrieben zu werden.

Ein häufiger Anwendungsfall, der nicht offensichtlich ist: Ersetzung durch einen STRING UNGLEICHER LÄNGE. Wenn der Ersetzungs-String breiter ist als das Rectangle, wandert der Text rechts davon entsprechend nach rechts; ist er schmaler, rückt der rechte Teil nach links. Damit lassen sich auch tabellarische Layouts in einem Rutsch verbreitern oder schmaler ziehen.

Zeilen nummerieren mit C-x r N

rectangle-number-lines erzeugt fortlaufende Nummern am linken Rand des Rectangles — ein kleines, aber überaus nützliches Werkzeug für Listen, Checklisten, Aufzählungen und Protokolle.

1. Rectangle aufspannen über die zu nummerierenden Zeilen. Für reine Zeilen-Nummerierung am Zeilenanfang reicht ein „Strich-Rectangle" der Breite 0 — Mark und Point beide auf Spalte 0, nur über mehrere Zeilen verteilt.
2. C-x r N drücken.
3. Optionaler Prompt nach dem Format-String. Default ist %d (Zahl plus Leerzeichen).

Vorher (Rectangle über Spalte 0 aller drei Zeilen)
foo
bar
baz

Nachher  (C-x r N, Default-Format „%d ")
1 foo
2 bar
3 baz

Mit Prefix-Argument startet die Nummerierung an einem beliebigen Wert: C-u 100 C-x r N beginnt bei 100. Der Format-String akzeptiert die üblichen Emacs-Lisp-Format-Codes — %d für die Zahl, %03d für drei Stellen mit führenden Nullen, beliebiger Text drumherum.

Format „%03d. "                Format „[%d] "
  001. foo                       [1] foo
  002. bar                       [2] bar
  003. baz                       [3] baz

Format „Step %d: "             Format „L%05d  "
  Step 1: foo                    L00001  foo
  Step 2: bar                    L00002  bar
  Step 3: baz                    L00003  baz

Damit lassen sich in Sekunden Markdown-Listen, durchnummerierte SQL-Schritte oder Test-Case-IDs erzeugen, ohne ein Snippet-System oder eine Macro-Aufnahme zu bemühen.

cua-rectangle-mark-mode als alternative Bedienung

Manche Anwender finden die Default-Bindings unter C-x r ... umständlich — vor allem, wer aus der CUA-Welt (Common User Access, also das gewohnte Cut/Copy/Paste-Modell mit C-x / C-c / C-v) kommt. Emacs bringt dafür ein eigenes Untermodul mit, das sich isoliert aktivieren lässt.

Variante A — Volle CUA-Bedienung (mit Cut/Copy/Paste auf C-x / C-c / C-v):

;; Volle CUA-Bedienung: Cut/Copy/Paste auf C-x/C-c/C-v
;; Achtung: belegt die Emacs-Prefixe C-x und C-c um
(cua-mode 1)

Variante B — Nur die Selektions-Features (empfohlen, wenn du die Emacs-Prefixe NICHT verlieren willst):

;; Nur die CUA-Selektion (inklusive Rectangle-Bedienung)
;; ohne dass C-x/C-c/C-v umbelegt werden
(cua-selection-mode 1)

Beide Snippets gehören in deine init.el. Wo diese liegt und wie sie geladen wird, behandelt der Artikel zur Konfiguration mit init.el und early-init.el ausführlich.

Im aktivierten CUA-Selektions-Modus bietet sich ein zusätzliches Bedien-Pattern an: C-RET startet eine Rectangle-Selektion direkt am Cursor, die mit Pfeiltasten / üblichen Bewegungsbefehlen erweitert wird. Tippt man dann Text, wird er — anders als bei string-rectangle — in jeder Zeile des Rechtecks am Cursor-Rand eingefügt. Das fühlt sich für Umsteiger aus Sublime Text oder VS Code wie ein „Multi-Cursor light" an und ist eine der elegantesten Möglichkeiten, mehrere Zeilen gleichzeitig zu editieren — ganz ohne externes Multi-Cursor-Paket.

Praktische Workflows

Sechs typische Aufgaben, bei denen Rectangles die elegante Antwort sind:

Eine Spalte aus einer Datentabelle extrahieren — Rectangle exakt über die Spalte aufspannen, C-x r M-w kopieren, in eine neue Buffer-Position springen, C-x r y einfügen. Die kopierte Spalte erscheint in der ursprünglichen Breite, jede Zeile am gleichen Spalten-Offset wie der Cursor.

Eine Spalte ersetzen (z. B. Spalte 3 einer CSV) — Rectangle über die Spalte 3, dann C-x r t, neuer Wert, RET. Wenn der neue Wert länger oder kürzer ist, verschieben sich die nachfolgenden Spalten entsprechend — fast immer das, was man möchte.

Mehrere Listen-Items fortlaufend nummerieren — Rectangle der Breite 0 am Zeilenanfang aller Items, C-x r N. Mit Format-String "%d. " ergibt das saubere Markdown-Listen.

Kommentar-Präfix in mehrere Zeilen einfügen — Mark in der ersten Zeile auf Spalte 0, Point in der letzten Zeile auf Spalte 0, M-x string-insert-rectangle, // eingeben. Vorhandener Inhalt wandert nach rechts; das Ergebnis ist ein blockweise auskommentierter Bereich, ohne den jeweiligen Major-Mode-Kommentar-Befehl zu nutzen.

Tabellarisches Auffüllen mit Whitespace — wenn ein Block visuell ausgerichtet werden soll, Rectangle an der gewünschten Stelle aufspannen und C-x r o: jede Zeile bekommt im Rectangle-Bereich Leerzeichen, der Inhalt rechts davon rückt mit. Praktisch zum Ausrichten von ASCII-Tabellen.

Code-Refactoring: Variablen-Präfixe umbenennen — Rectangle exakt über alle let -Tokens (oder var , const , final etc.) im sichtbaren Code-Bereich, dann C-x r t mit dem neuen Präfix. Funktioniert nur, wenn die Tokens an derselben Spalten-Position stehen — ist das der Fall, ist es schneller als jedes Suchen/Ersetzen.

Weiterführende Ressourcen

Externe Quellen

• GNU Emacs Manual — Rectangles — offizielle Referenz aller Rectangle-Befehle.
• GNU Emacs Manual — CUA Bindings — Details zu cua-mode, cua-selection-mode und der erweiterten Rectangle-Bedienung mit C-RET.
• Emacs Wiki — RectangleMark — Community-Sammlung mit Tipps und Beispielen zu Rectangle-Workflows.

Verwandte Artikel

• Region und Mark
• Kill-Yank-Konzept
• Kill-Befehle
• Register — Buffer-weite Marker und Snippets
• Multiple Cursors und iedit
• init.el und early-init.el