Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 3: Kommandozeile editieren wie ein Profi

Ziel: Du korrigierst jede Befehlszeile in Sekunden, ohne Pfeiltasten-Gehämmer, und lässt zsh das Tippen übernehmen. · Dauer: ca. 75 min · Voraussetzung: Tag 2

Briefing

  • Der Zeileneditor von zsh heißt ZLE. Er kennt einen Emacs- und einen vi-Modus. Die Emacs-Tasten funktionieren auch in bash, in psql, in Python und in jedem readline-Programm.
  • Drei Gruppen reichen für 90 Prozent: springen (⌃A, ⌃E, ⌥B, ⌥F), löschen (⌃W, ⌃U, ⌃K) und zurückholen (⌃Y).
  • Lange Befehle bearbeitest du im Editor: ⌃X⌃E.
  • History-Expansion (!!, !$, ^alt^neu), Brace Expansion ({a,b}) und Glob-Qualifier (*(.om)) sparen ganze Befehle.
 ⌃A        ⌥B         ⌥F          ⌃E
 |←────────|←──  ▮  ──→|─────────→|
 git commit -m "fix: rabatt" --amend
 ⌃U löscht ←───  ▮  ───→ ⌃K löscht

Drill 1: Welcher Modus läuft?

bindkey -lL main
env -i HOME=$HOME TERM=$TERM EDITOR=nvim zsh -f -i -c 'bindkey -lL main'
env -i HOME=$HOME TERM=$TERM zsh -f -i -c 'bindkey -lL main'

Erwartet:

bindkey -A emacs main
bindkey -A viins main
bindkey -A emacs main

Die Falle: Enthält $EDITOR oder $VISUAL die Buchstaben vi, schaltet zsh beim Start in den vi-Modus. Mit EDITOR=nvim funktioniert dann plötzlich ⌃A nicht mehr. Darum steht in deiner Lab-.zshrc seit Tag 2 bindkey -e.

Welche Funktion an einer Taste hängt, fragst du direkt ab:

for k in '^A' '^E' '^W' '^U' '^K' '^Y'; do bindkey $k; done

Erwartet:

"^A" beginning-of-line
"^E" end-of-line
"^W" backward-kill-word
"^U" kill-whole-line
"^K" kill-line
"^Y" yank

Immer nur eine Taste pro bindkey-Aufruf abfragen: Zwei Argumente hintereinander würden die erste Taste auf die zweite umbinden. ^A ist die Schreibweise für ⌃A, ^[ steht für Escape, also für ⌥ als Meta. Die Liste aller Funktionen steht in man zshzle, Abschnitt STANDARD WIDGETS.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Springen

Tippe die Zeile, aber ohne ⏎. Führe dann die Tasten aus und prüfe, wo der Cursor (▮) steht. Zum Schluss verwirft ⌃C die Zeile:

git commit -m "fix: rabatt" --amend
Tasten Cursor danach
⌃A ▮git commit -m "fix: rabatt" --amend
⌥F git ▮commit -m "fix: rabatt" --amend
⌃E git commit -m "fix: rabatt" --amend▮
⌥B git commit -m "fix: rabatt" ▮--amend
⌥B git commit -m "fix: ▮rabatt" --amend
⌥B git commit -m "▮fix: rabatt" --amend

Achtung, Unterschied zu bash: ⌥F springt in zsh an den Anfang des nächsten Worts, bash an das Ende des aktuellen.

Mit dem Preset „Natural Text Editing” aus Tag 1 gehen auch ⌥← und ⌥→. Ghostty und tmux schicken für ⌥← aber eine andere Sequenz (^[[1;3D). Die bindest du gleich mit.

Ein ganzes Wort ist für ⌥B alles aus Buchstaben, Ziffern und den Zeichen in $WORDCHARS:

echo $WORDCHARS

Erwartet:

*?_-.[]~=/&;!#$%^(){}<>

Der Schrägstrich / gehört standardmäßig zum Wort. Für zsh ist /usr/local/bin also ein einziges Wort. Das ändern wir in Drill 3.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Löschen und zurückholen

Was du mit ⌃W, ⌃U, ⌃K oder ⌥D löschst, landet im Kill-Ring. ⌃Y holt es zurück. Das ist Ausschneiden und Einfügen ohne Maus.

Erst der Standard. Tippe echo /usr/local/bin, dann ⌃W:

echo ▮

Der ganze Pfad ist weg, weil / zu $WORDCHARS gehört. Jetzt legst du die erste eigene ZLE-Datei an:

cat > ~/term-lab/config/zsh/zle.zsh <<'EOF'
# ~/term-lab/config/zsh/zle.zsh – Zeileneditor (Tag 3)
# ⌃W und ⌥⌫ stoppen an / . - : Pfade stückweise löschen
WORDCHARS=${WORDCHARS//[\/.-]}

# ⌃U wie in bash: nur links vom Cursor löschen
bindkey -M emacs '^U' backward-kill-line

# ⌃X⌃E: aktuelle Zeile im $EDITOR bearbeiten
autoload -Uz edit-command-line
zle -N edit-command-line
bindkey -M emacs '^X^E' edit-command-line

# ⌥← / ⌥→ auch in Ghostty und tmux (xterm-Sequenzen)
bindkey -M emacs '^[[1;3D' backward-word
bindkey -M emacs '^[[1;3C' forward-word

# Leertaste expandiert !!, !$ und !-2 sofort sichtbar
bindkey -M emacs ' ' magic-space
EOF
exec ~/term-lab/lab
echo $WORDCHARS
for k in '^U' '^X^E'; do bindkey $k; done

Erwartet:

*?_[]~=&;!#$%^(){}<>
"^U" backward-kill-line
"^X^E" edit-command-line

${WORDCHARS//[\/.-]} ist Parameter Expansion: ersetze alle /, . und - durch nichts. -M emacs bindet gezielt in die Emacs-Keymap. So stört es nicht, falls eine andere Datei zwischendurch den Modus wechselt.

Jetzt die Übungen. Links steht die Eingabe, in der Mitte die Tasten, rechts der Puffer danach:

Eingabe Tasten Ergebnis
echo /usr/local/bin ⌃W ⌃W echo /usr/
echo deploy/k8s/deployment.yaml ⌥⌫ echo deploy/k8s/deployment.
echo eins zwei drei ⌃A ⌥F ⌥D echo zwei drei
echo aaa bbb ccc ⌥B ⌥B ⌃K echo aaa
echo eins zwei drei ⌥B ⌃U drei
echo eins zwei ⌃W ⌃Y ⌃Y echo eins zweizwei
echo abc ⌃A ⌃K ⌃Y ⌃Y echo abcecho abc

Die letzte Zeile ist der Klassiker: ⌃A ⌃K schneidet die ganze Zeile aus, ⌃Y fügt sie wieder ein. So parkst du einen halben Befehl, tippst schnell etwas anderes und holst ihn zurück. Nach ⌃Y blättert ⌥Y durch ältere Einträge im Kill-Ring.

Achtung: ⌥⌫ braucht „Option als Meta” (Tag 1). Mit dem Preset „Natural Text Editing” schickt iTerm2 dafür ^W und für ⌘⌫ ein ^U. Das Ergebnis ist dasselbe.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Rückgängig, tauschen, parken

Eingabe Tasten Ergebnis
echo eins zwei ⌃W ⌃W ⌃_ echo eins
echo hallo welt ⌃T echo hallo wetl
echo abc def ⌥T echo def abc
echo shop ⌥B ⌥U echo SHOP
echo shop ⌥B ⌥C echo Shop

⌃_ ist Undo. Auf deutschen Tastaturen ist das ⌃⇧- und damit unhandlich. Gleichwertig ist ⌃X⌃U. ⌃T vertauscht die zwei Zeichen vor dem Cursor, ⌥T die zwei Wörter. Das rettet jeden Tippfehler wie sl statt ls.

Der unterschätzteste Trick ist push-line mit ⌥Q:

  1. Tippe git commit -m "wip", aber nicht ⏎.
  2. Dir fällt ein, dass du erst den Status sehen willst: ⌥Q. Die Zeile verschwindet.
  3. Tippe git status und ⏎.
  4. Der geparkte Befehl steht wieder am Prompt, Cursor am Ende.

Erwartet nach Schritt 3:

[lab] projekt % git status
Auf Branch main
nichts zu committen, Arbeitsverzeichnis unverändert
[lab] projekt % git commit -m "wip"▮

Fortschritt speichern? Kostenlos registrieren

Drill 5: Lange Befehle im Editor

Für alles über eine Zeile ist der Editor schneller. Tippe:

kubectl --context staging --namespace webshop get pods -o wide

Nicht ⏎, sondern ⌃X⌃E. Neovim öffnet den Befehl als Datei. Ändere staging zu prod mit :s/staging/prod/ und speichere mit :wq. Der geänderte Befehl steht wieder am Prompt, noch nicht ausgeführt:

[lab] ~ % kubectl --context prod --namespace webshop get pods -o wide▮

Mit :cq verlässt du Neovim mit Fehlercode. Dann verwirft zsh die Zeile. Und ein Befehl, den du schon abgeschickt hast, holst du mit fc direkt in den Editor (Tag 4).

Tipp: Für mehrzeilige Befehle, etwa eine for-Schleife oder ein curl mit JSON-Body, ist ⌃X⌃E die einzige vernünftige Art. Schreib sie im Editor sauber mit \ umbrochen, speichere, prüfe, dann ⏎.

Fortschritt speichern? Kostenlos registrieren

Drill 6: History-Expansion

Statt den letzten Befehl neu zu tippen, verweist du auf ihn. Dank magic-space aus Drill 3 siehst du die Ersetzung, sobald du die Leertaste drückst.

cd ~/term-lab/projekt
wc -l logs/app.log
grep ERROR !$ | head -2

Erwartet:

     500 logs/app.log
grep ERROR logs/app.log | head -2
2026-10-05T08:06:42 checkout ERROR request_id=r0006 user=u06
2026-10-05T08:16:52 checkout ERROR request_id=r0016 user=u16

!$ ist das letzte Wort des vorigen Befehls. zsh zeigt die expandierte Zeile, bevor sie läuft. Jetzt dieselbe Suche für Warnungen:

^ERROR^WARN

Erwartet:

grep WARN logs/app.log | head -2
2026-10-05T08:04:28 http WARN request_id=r0004 user=u04
2026-10-05T08:14:38 http WARN request_id=r0014 user=u14
Ausdruck Bedeutung Typischer Einsatz
!! ganzer letzter Befehl sudo !!
!$ letztes Wort mkdir neu && cd !$
!^ erstes Argument vim !^
!* alle Argumente ls -l !*
!-2 vorletzter Befehl
!git letzter Befehl, der mit git beginnt
^alt^neu letzten Befehl mit Ersetzung wiederholen Tippfehler

Noch schneller als !$ ist ⌥.: Es fügt das letzte Wort sofort ein. Mehrmals drücken geht weiter zurück in der History.

ls internal/cart
cd ⌥.

Erwartet im Puffer:

[lab] projekt % cd internal/cart▮

Fortschritt speichern? Kostenlos registrieren

Drill 7: Brace Expansion

Klammern erzeugen Wörter, bevor der Befehl läuft. Mit echo davor siehst du, was passieren würde:

echo cp config/app.yaml{,.bak}
echo mkdir -p tmp/{src,test}/{go,py}
echo {01..10..3} {a..e}

Erwartet:

cp config/app.yaml config/app.yaml.bak
mkdir -p tmp/src/go tmp/src/py tmp/test/go tmp/test/py
01 04 07 10 a b c d e

{,.bak} ist das schnellste Backup der Welt: leeres Wort plus .bak. Das echo-Vorschalten ist eine Senior-Gewohnheit: erst ansehen, dann ⌃A ⌥D ⌃D entfernt echo und ⏎ führt aus.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Globbing mit Qualifiern

Mit EXTENDED_GLOB (Tag 2) kann zsh mehr als *. Viele find-Aufrufe werden überflüssig:

print -l **/*.go
print -l **/*.(go|py)
print -l config/^*.json
print -l *(/) | head -3

Erwartet:

cmd/shop/main.go
internal/cart/cart.go
cmd/shop/main.go
internal/cart/cart.go
scripts/report.py
config/app.yaml
cmd
config
deploy

** geht rekursiv durch alle Ordner, (go|py) ist eine Alternative, ^ verneint. Die Klammer am Ende ist ein Qualifier:

print -l **/*(.Lk+10)
print -l **/*(.om[1,2])
print -l **/*(.x)
print **/*.go(:t)

Erwartet:

logs/access.log
logs/app.log
logs/access.log
logs/app.log
scripts/report.py
cart.go main.go
Qualifier Bedeutung find-Pendant
(.) / (/) nur Dateien / nur Ordner -type f / -type d
(.Lk+10) größer als 10 KB -size +10k
(.om[1,2]) nach Änderungszeit, neueste zwei ls -t, davon zwei
(.mh-1) in der letzten Stunde geändert -mmin -60
(.x) ausführbar -perm +111
(N) kein Fehler ohne Treffer
(:t) / (:r) nur Dateiname / ohne Endung basename

Hast du einen Glob getippt, zeigt ⇥ direkt die Treffer als Completion. So prüfst du ihn, bevor du rm davor schreibst.

Achtung: Findet ein Glob nichts, bricht zsh mit no matches found ab, anders als bash. Das ist gewollt und schützt dich. Mit (N) oder in Anführungszeichen ('*.log' für find oder rg) umgehst du es bewusst.

Fortschritt speichern? Kostenlos registrieren

Shortcut-Tabelle

Taste Wirkung Merkhilfe
⌃A / ⌃E Zeilenanfang / Zeilenende Anfang, Ende
⌥B / ⌥F Wort zurück / vor Back, Forward
⌃B / ⌃F Zeichen zurück / vor wie oben, nur klein
⌃W / ⌥⌫ Wort links löschen Wort weg
⌥D Wort rechts löschen Delete word
⌃U alles links vom Cursor löschen Undo the line
⌃K alles rechts vom Cursor löschen Kill rest
⌃Y / ⌥Y einfügen / ältere Einträge Yank
⌃_ / ⌃X⌃U rückgängig Unterstrich = zurück
⌃T / ⌥T Zeichen / Wörter tauschen Transpose
⌥U / ⌥L / ⌥C GROSS / klein / Groß am Anfang Upper, Lower, Capital
⌥Q Zeile parken, nach ⏎ zurück Queue
⌥. letztes Wort des vorigen Befehls Punkt = das Letzte
⌃X⌃E Zeile im Editor bearbeiten eXtern Editieren
⌃V + Taste Taste roh einfügen Verbatim
⌃C Zeile verwerfen Cancel
⌃L Bildschirm leeren Leeren

Kontrollpunkt

LAB=${LAB:-~/term-lab}
ok() { local m=$1; shift; "$@" >/dev/null 2>&1 && echo "✔ $m" || echo "✘ $m"; }
lab() { (cd "$LAB/projekt" && env ZDOTDIR="$LAB/zsh" zsh -i -c "$1" 2>/dev/null); }
ok "Emacs-Modus"          test "$(lab 'bindkey -lL main')" = "bindkey -A emacs main"
ok "⌃U links löschen"     lab '[[ $(bindkey "^U") == *backward-kill-line ]]'
ok "⌃X⌃E Editor"          lab '[[ $(bindkey "^X^E") == *edit-command-line ]]'
ok "Leertaste expandiert" lab '[[ $(bindkey " ") == *magic-space ]]'
ok "/ trennt Wörter"      lab '[[ $WORDCHARS != */* ]]'
ok "Glob: 3 Quelldateien" test "$(lab 'print -l **/*.(go|py) | wc -l')" -eq 3

Erwartet:

✔ Emacs-Modus
✔ ⌃U links löschen
✔ ⌃X⌃E Editor
✔ Leertaste expandiert
✔ / trennt Wörter
✔ Glob: 3 Quelldateien

Dazu der Handtest auf Zeit: Tippe kubectl get pods -n webshop -o wide und ändere ohne Pfeiltasten pods in deploy und wide in yaml. Unter zehn Sekunden ist gut.

Challenge

Im Projekt sollen alle .yaml-Dateien in .yml umbenannt werden, auch in Unterordnern. Ein Befehl, keine Schleife, und vorher ein Trockenlauf.

Hinweis: zsh bringt die Funktion zmv mit. Sie muss nur mit autoload geladen werden. -n zeigt nur, was passieren würde.

Lösung

cd ~/term-lab/projekt
autoload -Uz zmv
zmv -n '(**/)(*).yaml' '$1$2.yml'

Erwartet:

mv -- config/app.yaml config/app.yml
mv -- deploy/k8s/deployment.yaml deploy/k8s/deployment.yml

Die Klammern im Muster fangen Teile ein, $1 ist der Ordnerpfad, $2 der Name ohne Endung. Die einfachen Anführungszeichen sind Pflicht, sonst expandiert die Shell vorher. Ohne -n wird umbenannt. Zurück geht es mit zmv '(**/)(*).yml' '$1$2.yaml' oder mit git restore und git clean. Kürzer schreibt sich dasselbe mit zmv -W '**/*.yaml' '**/*.yml'.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Die Emacs-Tasten funktionieren auch in bash auf Servern, in psql, mysql, python3 und redis-cli. Was du heute übst, nimmst du auf jeden Jump-Host mit.
  • ⌃X⌃E ist die sichere Art, gefährliche Befehle zu bauen: erst im Editor prüfen, dann ausführen. Gerade bei kubectl delete oder terraform mit vielen Flags.
  • History-Expansion ist mächtig, aber tückisch in Skripten und Runbooks. Dort gehört der volle Befehl hin, nicht !!.
  • Vorsicht mit **/* in riesigen Monorepos oder auf Netzlaufwerken: Es läuft durch alles, auch node_modules. Dafür sind fd und rg mit .gitignore-Unterstützung da (Tag 6).
  • Wer im Team lieber vi-Tasten nutzt: bindkey -v plus KEYTIMEOUT=1. Mischen ist erlaubt, jede Person pflegt das in ihrer eigenen Konfiguration.