Zeichen, Wort und Zeile bewegen

Zeichenweise bewegen

Die kleinste Bewegungs-Einheit ist ein einzelnes Zeichen. Vorwärts wie rückwärts ein Zeichen — das sind die beiden Brot-und-Butter-Befehle:

• Vorwärts ein Zeichen — C-f ruft forward-char auf.
• Rückwärts ein Zeichen — C-b ruft backward-char auf.

Beide Funktionen sind auch über M-x forward-char bzw. M-x backward-char erreichbar — relevant vor allem dann, wenn du sie aus eigenem Elisp-Code aufrufst.

Mit einem numerischen Prefix-Argument wird die Bewegung mehrfach ausgeführt: C-u 10 C-f springt zehn Zeichen vorwärts, C-u 3 C-b drei Zeichen rückwärts. Dazu mehr in Sektion 06.

Die Pfeiltasten left und right sind in Vanilla-Emacs an dieselben Funktionen gebunden und tun das Gleiche — sie sind aber unidiomatisch, weil die Hand dafür das Heim-Block verlässt. Wer Emacs ernsthaft nutzt, gewöhnt sich C-f/C-b von Anfang an an: jede einzelne Bewegung spart einen Bruchteil einer Sekunde, in Summe über einen Arbeitstag erheblich.

Wortweise bewegen

Eine Stufe gröber als das einzelne Zeichen ist das Wort. Hier wechselt der Modifier von Strg auf Meta — das ist Emacs' systematisches Muster: C- für die feinkörnige, M- für die gröbere Variante desselben Befehls.

• Vorwärts ein Wort — M-f ruft forward-word auf.
• Rückwärts ein Wort — M-b ruft backward-word auf.

Was als „Wort" gilt, hängt vom Major-Mode des aktuellen Buffers ab. Emacs definiert Wortgrenzen über eine sogenannte syntax-table — eine Tabelle, in der jedes Zeichen einen Syntax-Typ trägt (Wort-Zeichen, Trennzeichen, Klammer, String-Delimiter usw.). Pro Major-Mode wird diese Tabelle anders belegt:

• In text-mode und org-mode sind nur Buchstaben und Ziffern Wort-Zeichen — Bindestrich - und Unterstrich _ zählen als Trennzeichen.
• In den meisten Programmier-Modes (z. B. python-mode, js-mode) ist _ Wort-Zeichen, weil snake_case als ein einzelner Bezeichner gemeint ist.
• In Lisp-Modes ist auch - Wort-Zeichen — my-cool-function ist ein Wort.

Der praktische Effekt: Dasselbe M-f springt in einem Markdown-Buffer Wort für Wort über einen kebab-case-bezeichner, im Python-Buffer dagegen über snake_case_variable in einem Rutsch.

CamelCase mit subword-mode

Für Sprachen mit CamelCase-Bezeichnern wie Java, TypeScript oder Swift gibt es einen Minor-Mode, der M-f/M-b an Großbuchstaben-Grenzen anhalten lässt:

;; subword-mode für alle Programmier-Buffer einschalten
(add-hook 'prog-mode-hook #'subword-mode)

Mit aktivem subword-mode wird getElementById zu drei Wörtern (get, Element, ById), und MyClassName zu drei (My, Class, Name). Das gilt symmetrisch für vorwärts wie rückwärts und für alle Befehle, die forward-word/backward-word intern verwenden (etwa M-d zum Löschen eines Wortes). Wo dieser Snippet hingehört, erklärt der Artikel zur Konfiguration mit init.el und early-init.el.

Zeilenweise bewegen

Vertikale Bewegung folgt dem gleichen Muster, nur mit den Buchstaben n („next") und p („previous"):

• Nächste Zeile — C-n ruft next-line auf.
• Vorige Zeile — C-p ruft previous-line auf.

Auch hier funktionieren die Pfeiltasten up/down identisch — und auch hier gilt die Heim-Block-Regel: C-n/C-p ist auf Dauer schneller.

Wunsch-Spalte beibehalten

Emacs hat eine angenehme Eigenheit beim vertikalen Bewegen: Er merkt sich die Wunsch-Spalte, in der du dich befandest, als du die vertikale Bewegung begonnen hast. Springst du mit C-n durch eine kürzere Zeile hindurch, landet der Cursor dort am Zeilenende — aber sobald wieder eine ausreichend lange Zeile kommt, kehrt er zur ursprünglichen Spalte zurück.

Beispiel mit Cursor | in Spalte 12:

Die erste|Zeile ist lang genug.       ← Start, Spalte 12
Kurz.                                  ← C-n: Cursor ans Ende (Spalte 5)
Die dritte Z|eile fängt es wieder.    ← C-n: zurück zu Spalte 12

Verwandt dazu ist die Variable track-eol. Steht sie auf t, „klebt" der Cursor am Zeilenende: hast du ihn einmal mit C-e ans Ende einer Zeile gesetzt, bleibt er bei jedem folgenden C-n/C-p am jeweiligen Zeilenende — auch wenn die Zeilen unterschiedlich lang sind. Praktisch für „letztes Zeichen jeder Zeile bearbeiten"-Workflows:

;; Cursor klebt am Zeilenende, sobald er einmal dort war
(setq track-eol t)

Visuelle vs. logische Zeilen

Standardmäßig bewegen sich C-n/C-p über visuelle Zeilen (line-move-visual = t) — bei umbrochenen langen Zeilen springst du also pro Tastendruck eine Bildschirm-Zeile, nicht eine logische Datei-Zeile. Wer das umgekehrte Verhalten will (etwa für Listen-Verarbeitung), setzt (setq line-move-visual nil) — dann zählt die logische Zeile.

Zeilenanfang und Zeilenende

Die ersten und letzten beiden Positionen einer Zeile erreicht man mit a („anfang") und e („ende"):

• An den Zeilenanfang — C-a ruft move-beginning-of-line auf.
• Ans Zeilenende — C-e ruft move-end-of-line auf.

Die home- und end-Tasten sind ebenfalls daran gebunden und funktionieren identisch — auch hier ist die Buchstaben-Variante idiomatisch.

back-to-indentation: meist die bessere Wahl

In eingerücktem Code ist C-a selten das, was du wirklich willst: Du landest am Spaltennull-Zeichen, also vor der Einrückung. Viel öfter willst du zum ersten Inhalts-Zeichen einer Zeile — also hinter die Einrückung. Dafür gibt es back-to-indentation:

• M-m ruft back-to-indentation auf.

Beispiel mit Cursor-Position |:

|    if (user.isActive) {     ← C-a landet hier (Spalte 0)
    |if (user.isActive) {     ← M-m landet hier (erster Nicht-Whitespace)

Toggle zwischen C-a und M-m

Ein beliebter Komfort-Trick: C-a so umbauen, dass es bei wiederholtem Drücken zwischen Spalte 0 und Indentation toggelt — einmal C-a führt zum ersten Inhalts-Zeichen, ein zweites C-a direkt danach zur tatsächlichen Spalte 0. Das externe Paket crux bringt das fertig als crux-move-beginning-of-line. Eine eigene Variante ohne externes Paket:

(defun mibeon/smart-beginning-of-line ()
  "Toggle zwischen Indentation und Spalte 0."
  (interactive)
  (let ((orig (point)))
    (back-to-indentation)
    (when (= orig (point))
      (move-beginning-of-line 1))))

(keymap-global-set "C-a" #'mibeon/smart-beginning-of-line)

Wo dieser Code hingehört, erklärt das Konfigurations-Kapitel.

macOS und die Cmd-Pfeil-Erwartung

Wer aus VS Code, TextEdit, Pages oder anderen macOS-Apps kommt, hat eine sehr bestimmte Erwartung an die Pfeiltasten in Kombination mit Modifiern:

Vanilla-Emacs ignoriert Cmd standardmäßig. Die Cmd-Pfeil-Tasten machen also schlicht nichts — was beim Umstieg von macOS-Editoren extrem irritierend ist. Option ist je nach Konfiguration entweder als Meta belegt (siehe Meta-Taste konfigurieren) oder bleibt für deutsche Sonderzeichen frei — Option+f wird in Emacs zu M-f, also wortweise vorwärts, aber Option+← ist nicht automatisch belegt.

Mac-Konventionen nachbauen

Wer die macOS-Reflexe behalten will, baut die Bindings einfach nach. Vorausgesetzt, Cmd ist als Super belegt (mac-command-modifier 'super):

;; Nur auf macOS aktivieren, sonst stören die Bindings woanders nicht
(when (eq system-type 'darwin)
  ;; Cmd+Pfeil-Links/Rechts: Zeilenanfang / Zeilenende
  (keymap-global-set "s-<left>"  #'move-beginning-of-line)
  (keymap-global-set "s-<right>" #'move-end-of-line)

  ;; Cmd+Pfeil-Hoch/Runter: Buffer-Anfang / Buffer-Ende
  (keymap-global-set "s-<up>"    #'beginning-of-buffer)
  (keymap-global-set "s-<down>"  #'end-of-buffer)

  ;; Option+Pfeil-Links/Rechts: wortweise (Option = Meta hier nicht nutzbar,
  ;; daher direkt aufs Modifier-Symbol mappen)
  (keymap-global-set "M-<left>"  #'backward-word)
  (keymap-global-set "M-<right>" #'forward-word))

Wo dieser Code hingehört, beschreibt das Konfigurations-Kapitel. Hinweis: Damit s-<...> überhaupt anspricht, muss Cmd in der Konfiguration als Super gemappt sein — Details im Artikel Tasten-Notation.

Eine Geschmacksfrage bleibt: Manche Umsteiger bauen die Bindings dauerhaft nach, andere zwingen sich in der ersten Woche bewusst zu den Emacs-Defaults, um den „echten" Workflow zu lernen. Beides ist legitim — wichtig ist, sich für eine Strategie zu entscheiden, statt jeden Tag zwischen den Mustern hin und her zu denken.

Numerische Prefix-Argumente — dieselben Befehle, mehr Distanz

Jeder Bewegungs-Befehl in Emacs akzeptiert ein numerisches Prefix-Argument, das angibt, wie oft der Befehl ausgeführt werden soll. Damit wird aus „ein Wort vorwärts" sofort „fünf Wörter vorwärts" — ohne dass ein eigener Befehl dafür existieren müsste.

Es gibt zwei Schreibweisen für Prefix-Argumente:

• C-u N — universelles Prefix, gefolgt von der Zahl und dem Befehl.
• M-N — Meta mit Ziffer ist ein Shortcut für dasselbe (nur für Ziffern 0–9 sinnvoll, bei mehrstelligen einfach Ziffern nacheinander mit Meta tippen).

Ein paar Beispiele:

Das Minus-Argument (M-- bzw. C-u -) kehrt die Richtung eines Befehls um — das ist besonders bei Befehlen praktisch, die keine eigene Rückwärts-Variante haben. C-u 50 C-n ist in vielen Fällen schneller als zu scrollen oder die Maus zu greifen, und der Mehraufwand gegenüber C-n C-n C-n... lohnt sich ab ca. fünf Wiederholungen.

Mehr zum Mechanismus selbst im Artikel zu den M-x-Befehlen — Prefix-Argumente sind in Emacs universell und funktionieren mit fast jedem interaktiv aufrufbaren Befehl, nicht nur mit Bewegungen.

Idiomatische Bewegung — Workflow-Sammlung

Die einzelnen Befehle sind nur die halbe Miete — ihr Wert entsteht aus Kombinationen. Eine Auswahl praxis-relevanter Muster, die in Emacs als „idiomatisch" gelten:

• An den Anfang der Inhalts-Zeile: M-m statt C-a — bei eingerücktem Code spart das einen Tastendruck und ein „nochmal überlegen".
• Ein Wort markieren: C-SPC M-f setzt eine Mark und springt ein Wort weiter — die dazwischenliegende Region ist markiert.
• 50 Zeilen nach unten ohne Scrollen: M-5 0 C-n — schneller als jede Maus-Operation.
• Wort rückwärts löschen: M-DEL ruft backward-kill-word auf — kombiniert Navigation und Edit in einem Befehl. Pendant vorwärts: M-d (kill-word).
• Vom Cursor bis Zeilenende killen: C-k (kill-line) — entfernt alles ab Cursor bis Zeilenende und packt es in den Kill-Ring. Mit Prefix-Argument C-u 5 C-k werden fünf ganze Zeilen gekillt.
• Wort transponieren: M-t (transpose-words) tauscht das Wort vor dem Cursor mit dem dahinterstehenden — Tipp-Fehler-Reparatur in einem Tastendruck.

Diese Mini-Workflows zeigen das Grundprinzip von Emacs: einzelne, kleine, gut benannte Befehle, die sich frei kombinieren lassen. Das ist deutlich anders als das „eine Taste, ein Großbefehl"-Modell vieler GUI-Editoren — und genau deshalb wird Emacs auf Dauer schneller.

Weiterführende Ressourcen

Externe Quellen

• GNU Emacs Manual — Moving Point — offizielle Referenz aller Punkt-Bewegungs-Befehle inklusive track-eol und line-move-visual.
• GNU Emacs Manual — Words — wortbasierte Befehle und das Zusammenspiel mit der syntax-table.
• GNU Emacs Manual — Arguments — vollständige Doku zu numerischen Prefix-Argumenten.
• Emacs Wiki — Subword Mode — Praxis-Sammlung rund um CamelCase-Navigation.
• bbatsov/crux — beliebtes Helfer-Paket mit smartem C-a-Toggle und vielen weiteren Mini-Verbesserungen.

Verwandte Artikel

• Point und Cursor
• Satz, Absatz, Funktion bewegen
• Buffer-Anfang, -Ende und Sprünge
• Tasten-Notation
• Meta-Taste konfigurieren
• Kill-Befehle