Erste Schritte
Modi & Grundbewegung
Vim ist modal — verschiedene Modi dienen verschiedenen Zwecken. Esc kehrt aus jedem anderen Modus in den Normalmodus zurück. Die Tasten hjkl halten deine Hände auf der Grundreihe. w/b bewegen nach Wort, 0/$ zu Zeilengrenzen, gg/G an Dateianfang/-ende, :N springt zu Zeile N.
# Vim Modes
# Normal mode (Esc) - default, for navigation
# Insert mode (i) - for typing text
# Visual mode (v) - for selecting text
# Command mode (:) - for Ex commands
# Basic movement (Normal mode)
h # left
j # down
k # up
l # right
w # next word start
b # previous word start
0 # beginning of line
$ # end of line
gg # first line
G # last line
:42 # go to line 42Beenden & Speichern
ZZ und ZQ sind die schnellsten Wege zu beenden — der Doppelpunkt muss nicht erreicht werden. :x schreibt nur, wenn sich die Datei geändert hat (erhält die mtime), anders als :wq, das immer schreibt. :w! überschreibt Read-only-Flags, wenn Dateisystemrechte es erlauben. :qa! nutzen, um aus mehreren geänderten Buffers auszusteigen.
:w # write (save) file
:w! # force write (override read-only)
:q # quit
:q! # force quit (discard changes)
:wq # write and quit
:x # write only if changed, then quit
ZZ # same as :x (write if changed, quit)
ZQ # quit without saving (like :q!)
:w newfile.txt # save as new file
:sav newfile.txt # save as new file and switch to it
:wa # write all buffers
:xa # write all changed buffers and exit
:qa! # force quit all (discard everything)Hilfesystem
Vims Hilfe ist umfassend und hyperlinkt. Ctrl-] folgt einem Tag (Link), Ctrl-T springt zurück. Hilfenotation: i_CTRL-N heißt Ctrl-N im Insert-Modus, 'number' (mit Anführungszeichen) eine Option. :helpgrep durchsucht alle Hilfedateien auf einmal — mit :cn/:cp durch Treffer navigieren. K ruft man für das Schlüsselwort unter dem Cursor auf (konfigurierbar über 'keywordprg').
:help # main help
:help subject # help on subject (e.g. :help insert)
:help i_CTRL-N # help on Ctrl-N in insert mode
:help 'number' # help on the 'number' option (quotes)
:helpgrep pattern # search all help files for pattern
:cn / :cp # next/prev helpgrep match
K # man page for word under cursor (Normal mode)
Ctrl-] # jump to tag under cursor (follow link)
Ctrl-T # jump back from tag (pop tag stack)
:helptags ~/.vim/doc # regenerate help tags for a doc directoryWort- & Zeichenbewegung
Kleinbuchstaben-Motions (w/b/e) behandeln Interpunktion als Worttrenner — nützlich für Code. Großbuchstaben-Motions (W/B/E) behandeln nur Whitespace als Trenner — nützlich für Fließtext. e/E bewegen zum Ende des nächsten Worts; ge/gE zum Ende des vorherigen (selten genutzt, aber praktisch).
# Word motions (punctuation-aware)
w # next word start
b # previous word start
e # end of next word
ge # end of previous word
# WORD motions (whitespace-only delimiters, uppercase)
W # next WORD start
B # previous WORD start
E # end of next WORD
gE # end of previous WORD
# Word boundaries:
# word: sequence of word-characters OR sequence of punctuation
# WORD: anything separated by whitespace
# Examples (cursor on 'a' in "foo.bar baz"):
# w -> 'bar' (punctuation splits words)
# W -> 'baz' (only whitespace splits WORDS)Zeilenbewegung
0 und $ gehen an absoluten Zeilenanfang/-ende (inklusive Whitespace). ^ und g_ überspringen führenden/nachgestellten Whitespace — meist das Gewollte. Ist 'wrap' an, arbeiten g0/g$ auf Bildschirmzeilen, während 0/$ auf logischen Zeilen arbeiten. | springt zu einer bestimmten Spaltennummer.
0 # first column (absolute start)
^ # first non-blank character
$ # end of line (last character)
g_ # last non-blank character
g0 # start of screen line (with wrap)
g$ # end of screen line (with wrap)
gm # middle of screen line
gM # middle of text line
| # column N (e.g. 10| = column 10)
+ # first non-blank of next line
- # first non-blank of previous line
_ # first non-blank of current line [count down]Datei- & Bildschirmbewegung
H/M/L springen innerhalb des sichtbaren Bildschirms. Ctrl-d/u scrollt eine halbe Seite (weniger desorientierend als ganzseitiges Ctrl-f/b). zz/zt/zb scrollt die aktuelle Zeile zur Mitte/oben/unten des Bildschirms, ohne den Cursor zu bewegen — extrem nützlich, um beim Bearbeiten Kontext zu behalten. N% springt zu einem Prozentsatz der Datei.
gg # go to first line
G # go to last line
Ngg / NG # go to line N (e.g. 50gg or 50G)
:N # go to line N (Ex command)
H # top of screen (High)
M # middle of screen
L # bottom of screen (Low)
N% # jump to N% of the file
Ctrl-f # scroll forward (full page)
Ctrl-b # scroll backward (full page)
Ctrl-d # scroll down (half page)
Ctrl-u # scroll up (half page)
zz # scroll current line to middle
zt # scroll current line to top
zb # scroll current line to bottomText einfügen
Einfaches Einfügen (i, I)
i/I fügen vor dem Cursor / am Zeilenanfang ein. a/A nach dem Cursor / am Zeilenende. gi kehrt zur letzten Einfügeposition zurück (Mark '^) — praktisch, wenn du Esc für etwas gedrückt hast und weitertippen willst. gI geht zur absoluten Spalte 1 und ignoriert führenden Whitespace.
i # insert before cursor
I # insert at first non-blank (same as ^i)
gi # insert at last insert position (also sets mark)
gI # insert at column 1 (same as 0i)
a # insert after cursor
A # insert at end of line (same as $a)
# Examples:
# foo|bar + i -> foo|bar (cursor stays, type before)
# foo|bar + I -> |foobar (cursor at first non-blank)
# foo|bar + A -> foobar| (cursor at end)
# gi returns to where you last left insert mode —
# very useful after escaping to run a Normal-mode command.Neue Zeilen öffnen (o, O)
o und O öffnen unter/über dem Cursor eine neue Zeile und gehen in den Insert-Modus. Der schnellste Weg, eine Zeile zu ergänzen — der Cursor muss nicht ans Zeilenende positioniert werden. Die Einrückung wird automatisch aus den umgebenden Zeilen kopiert (gesteuert durch 'autoindent').
o # open new line BELOW cursor, enter insert
O # open new line ABOVE cursor, enter insert
# Before (cursor on middle line):
# line one
# li|ne two
# line three
# After 'o':
# line one
# line two
# | <- new blank line, insert mode
# line three
# After 'O':
# line one
# | <- new blank line, insert mode
# line two
# line threeChange-Befehle (c, C, s, S)
c{motion} löscht das Motion-Ziel und geht in den Insert-Modus — der flexibelste Bearbeitungsbefehl. C ist c$ (ändern bis Zeilenende), S ist cc (ganze Zeile ändern). s löscht ein Zeichen und geht in den Insert-Modus; mit Zählern wie 3s kombinieren. ciw/caw nutzen Text-Objekte (siehe eigene Sektion).
cw / ce # change to end of word
cb # change backward to word start
c$ / C # change to end of line
cc / S # change entire line
c0 # change to beginning of line
c^ # change to first non-blank
ct, # change up to (but not including) next ','
cfx # change up to and including next 'x'
ciw # change inner word (no surrounding whitespace)
caw # change a word (with surrounding whitespace)
cap # change around paragraph
s # substitute: delete char under cursor, insert
S # substitute: delete entire line, insert (like cc)Replace-Modus (r, R, gr)
r ersetzt ein einzelnes Zeichen und kehrt sofort in den Normalmodus zurück (kein Moduswechsel). R geht in den Replace-Modus, wo Tippen Zeichen überschreibt — Backspace stellt sie wieder her, anders als der Insert-Modus, der nur löscht. gr/gR (virtual replace) bei Tabs nutzen — er erhält die Tab-Ausrichtung, statt Text zu verschieben.
r{x} # replace single char under cursor with x
gr{x} # virtual replace (doesn't shift tabs)
R # enter Replace mode (overwrite until Esc)
gR # virtual Replace mode (tabs stay aligned)
3r{x} # replace 3 chars with x (single char only)
# In Replace mode, typing overwrites existing text
# but Backspace restores the original characters.
# Tabs are preserved with virtual replace (gr/gR).
# Examples:
# abc|def + rx -> abc|xef (cursor advances)
# abc|def + R -> enter Replace mode
# type 'XYZ' -> abcXYZ|f
# Backspace -> abcXY|def (original restored)Besondere Einfügungen
:r !cmd fügt Shell-Befehlsausgabe in den Buffer ein — super, um Befehlsausgaben, Daten oder Dateilisten einzufügen. Im Insert-Modus fügt Ctrl-r gefolgt von einem Register-Namen dieses Register ein; Ctrl-r = wertet einen Vimscript-Ausdruck aus und fügt das Ergebnis ein. Ctrl-k fügt ein Digraph (Sonderzeichen) ein, indem zwei ASCII-Zeichen getippt werden.
:r file.txt # insert contents of file below cursor
:r !command # insert output of shell command
:0r !date # insert date at top of file
:r !ls -la # insert directory listing
# Insert with special registers
Ctrl-r = # expression register: evaluate, insert result
Ctrl-r " # insert unnamed register
Ctrl-r % # insert current filename
# Insert from current file path
:i! !pwd # insert pwd output (no autoindent)
# Non-ASCII / digraphs (in insert mode)
Ctrl-k {ch1}{ch2} # digraph: e.g. Ctrl-k e' produces é
:digraphs # list available digraphsInsert-Modus-Shortcuts
Ctrl-h/w/u arbeiten innerhalb des Insert-Modus wie Backspace/Wort löschen/Zeile löschen. Ctrl-t/Ctrl-d passen die Einrückung an, ohne den Insert-Modus zu verlassen — unbezahlbar für Code. Ctrl-n/Ctrl-p machen Schlüsselwortvervollständigung aus Buffers und Tags. Ctrl-o führt einen einzigen Normalbefehl aus und kehrt in den Insert-Modus zurück (z. B. Ctrl-o zz zum Neuzentrieren). Ctrl-g u bricht die Undo-Kette, sodass ein langes Einfügen stückweise rückgängig gemacht werden kann.
# In insert mode:
Ctrl-h # delete char before cursor (Backspace)
Ctrl-w # delete word before cursor
Ctrl-u # delete to start of line
Ctrl-t # indent current line (one shiftwidth)
Ctrl-d # dedent current line (one shiftwidth)
Ctrl-n # keyword completion (forward)
Ctrl-p # keyword completion (backward)
Ctrl-o # execute one Normal command, return to insert
Ctrl-r {reg} # insert register contents
Ctrl-a # insert text typed in last insert mode
Ctrl-@ # insert last text + Esc (like Ctrl-a then Esc)
Ctrl-g u # break undo sequence (start new undo block)
Ctrl-] # trigger abbreviation without insertingBearbeitungsbefehle (Löschen/Yank/Einfügen)
Löschbefehle
d{motion} ist der universelle Löschoperator — mit jedem Motion kombinierbar. dd löscht die ganze Zeile. x ist die Kurzform für dl (Zeichen löschen). Gelöschter Text landet im unbenannten Register (und Register 1). d mit Text-Objekten nutzen (ciw, dib) für mächtige Bearbeitungen. J fügt die nächste Zeile mit einem Leerzeichen an die aktuelle an.
x # delete char under cursor (also 'dl')
X # delete char before cursor (also 'dh')
dd # delete current line
dw # delete to next word start
de # delete to end of word
d$ / D # delete to end of line
d0 # delete to beginning of line
d^ # delete to first non-blank
dgg # delete from cursor to first line
dG # delete from cursor to last line
J # join next line (removes leading whitespace, inserts space)
gJ # join next line without inserting space
3dd # delete 3 lines
dW # delete WORD (whitespace-separated)Yank (Kopieren)
y{motion} kopiert Text, ohne zu löschen. yy yankt die Zeile. Anders als d (das x als Kurzform hat) hat y keine Ein-Zeichen-Kurzform — ein Motion ist Pflicht. Yank aktualisiert immer Register 0, nützlich zur Unterscheidung von Löschungen. Text-Objekte nutzen: ya( yankt um Klammern herum, yi" innerhalb von Anführungszeichen.
y # yank {motion} (no character shortcut)
yy / Y # yank current line
yw # yank to next word start
ye # yank to end of word
y$ # yank to end of line
y0 # yank to beginning of line
yG # yank to end of file
ygg # yank to beginning of file
5yy # yank 5 lines
ya( # yank around parentheses
yi" # yank inside double quotes
yt, # yank up to (not including) next comma
# Yanked text goes to:
# " (unnamed register)
# 0 (yank register, only updated by y)Put (Einfügen)
p fügt nach dem Cursor ein (oder unter der Zeile bei lineweisen Daten); P davor. gp/gP bewegen den Cursor an das Ende des eingefügten Texts — nützlich beim Verketten von Operationen. ]p/[p rücken eingefügte Zeilen neu ein, passend zur Umgebung. Das Clipboard-Register (+) teilt sich mit der Systemzwischenablage, wenn 'clipboard' richtig gesetzt ist.
p # paste after cursor (linewise: line below)
P # paste before cursor (linewise: line above)
gp # paste after, leave cursor on last pasted char
gP # paste before, leave cursor on last pasted char
]p # paste after, reindent to match
[p # paste before, reindent to match
"+p # paste from system clipboard
"*p # paste from primary selection (X11)
# Linewise vs charwise:
# yy + p -> pasted as a new line below
# y$ + p -> pasted after cursor on same line
# Counts: 3p pastes the register 3 times.Groß-/Kleinschreibung ändern
~ kippt ein einzelnes Zeichen und rückt weiter. g~/gu/gU sind Operatoren, die mit Motions oder Text-Objekten arbeiten. Im Visual-Modus wirken U/u/~ auf die Auswahl. gUiw, um das aktuelle Wort großzuschreiben, gUU für die ganze Zeile. Diese sind destruktionsfrei — nur die Schreibweise ändert sich.
~ # toggle case of char under cursor (advances)
3~ # toggle case of next 3 chars
g~{motion} # toggle case of motion
gu{motion} # lowercase motion
gU{motion} # uppercase motion
g~~ # toggle case of current line
guu # lowercase current line
gUU # uppercase current line
g~~gg # toggle case to first line
# Visual mode:
# U # uppercase selection
# u # lowercase selection
# ~ # toggle case of selection
# Examples:
# hello + gUw -> HELLO
# HELLO + guw -> hello
# hello + g~w -> HELLOZeilen verbinden & splitten
J verbindet Zeilen mit einem einzigen Leerzeichen; gJ verbindet ohne etwas einzufügen. :join arbeitet auf einem Bereich. gq ist der Formatierungsoperator — er bricht Zeilen auf 'textwidth' um (üblich 80) und respektiert 'formatoptions'. gqip, um einen Absatz neu zu fließen, gqq für eine Zeile. 'textwidth=80' setzen, um automatischen Umbruch zu aktivieren.
J # join next line with current (inserts space)
gJ # join next line without inserting space
3J # join next 3 lines into one
:[range]join # join lines in range (also :j)
:[range]join! # join without inserting space
# Splitting a line:
# In insert mode, press Enter (autoindent applies)
# In normal mode: r<Enter> replaces char with newline
# Break a long line at column 80 (with 'textwidth'):
gq{motion} # format motion text to 'textwidth'
gqq # format current line
gqip # format paragraph
gvgq # format visual selection
# Set text width:
:set textwidth=80Wiederholen & Undo
. wiederholt die letzte Änderung — die nützlichste einzelne Taste in Vim. u/Ctrl-r sind undo/redo. U macht alle Änderungen der aktuellen Zeile rückgängig. :earlier/:later können per Zeit oder Anzahl in die Vergangenheit/Zukunft reisen, sogar über Zweige hinweg (Vim hält einen Undo-Baum). :undolist zeigt Zweige. @: wiederholt den letzten Ex-Befehl, & die letzte Substitution.
. # repeat last change (most powerful key in Vim)
u # undo
Ctrl-r # redo
U # undo all changes on current line
:Nu # undo N changes
:earlier 10m # revert to state 10 minutes ago
:later 5 # redo 5 changes
:undolist # show undo tree branches
# Repeat with counts:
5. # repeat last change 5 times
# Repeat Ex commands:
@: # repeat last :command
& # repeat last :s (substitute)
# Repeat macros/marks across files:
:& # repeat last substitute on current lineSuche & Substitution
Einfache Suche
/ und ? suchen vorwärts/rückwärts; n/N wiederholen. * sucht das ganze Wort unter dem Cursor (Wortgrenzen), g* jedes Teilstring-Match. :noh löscht die aktuelle Hervorhebung bis zur nächsten Suche. 'hlsearch' setzen, um alle Treffer dauerhaft hervorzuheben, 'incsearch' für inkrementelles Matching beim Tippen.
/pattern # search forward for pattern
?pattern # search backward
n # repeat search (same direction)
N # repeat search (opposite direction)
* # search forward for word under cursor
# # search backward for word under cursor
g* # search forward (loose, matches substring)
g# # search backward (loose)
# Search history:
# Press / then Up/Down to recall previous searches
# Clear search highlighting:
:nohlsearch # or :noh
# Toggle 'hlsearch' permanently:
:set hlsearch!Suchoptionen
'ignorecase' + 'smartcase' ist die empfohlene Kombination: schreibunabhängig, außer dein Muster enthält einen Großbuchstaben. \c/\C überschreibt die Schreibweise pro Suche. \v aktiviert den 'very magic'-Modus, in dem viele Zeichen ohne Escaping besonders werden — sauberere Regex-Syntax. Suchoffsets (e, b) platzieren den Cursor relativ zum Match.
:set ignorecase # case-insensitive search (ic)
:set smartcase # case-sensitive if pattern has uppercase
:set hlsearch # highlight all matches (hls)
:set incsearch # show match as you type (is)
:set wrapscan # wrap around end of file (ws)
:set gdefault # add 'g' flag to all :s by default
# Per-search case override:
/foo\c # case-insensitive search for foo
/foo\C # case-sensitive search for foo
# Use very-magic mode (less escaping):
/foo\v(.+)@<=(bar) # very magic regex
# Search offsets:
/foo/e # cursor on last char of match
/foo/e+2 # cursor 2 chars past match
/foo/b-1 # cursor 1 char before matchSuchmuster (Regex)
Vim-Regex unterscheidet sich von PCRE — Backslashes sind nötig für +, =, {, (, |. Den Präfix \v für den 'very magic'-Modus nutzen, wo diese ohne Escaping besonders werden (näher an PCRE). \< \> markieren Wortgrenzen. \d/\w/\s sind Zeichenklassen. \(...\) für Capturing-Gruppen, \1/\2 für Backreferences.
# Standard Vim regex (default magic mode)
. # any char
* # zero or more (preceding atom)
\+ # one or more
\= # zero or one (optional)
\{n,m} # between n and m
^ $ # start/end of line
\< \> # word boundaries
[abc] # char class (a, b, or c)
[^abc] # negated char class
\( \) # group
\1 \2 # backreference
\| # or
# Predefined classes:
\d \D # digit / non-digit
\w \W # word char / non-word
\s \S # whitespace / non-whitespace
# Very magic (\v prefix) — less escaping:
/\v\w+\s+\w+ # word, spaces, word (no backslashes needed)
/\v(%d+) # capture one-or-more digitsSubstitute-Befehl
:[range]s/pattern/replacement/flags ist der substitute-Befehl. :% heißt die ganze Datei. Ohne 'g'-Flag wird nur der erste Match pro Zeile ersetzt; 'g' ersetzt alle. 'c' fragt nach Bestätigung (y/n/a/q/l). \v für very-magic nutzen, um die Gruppensyntax zu vereinfachen. Capture-Gruppen werden in der Ersetzung als \1, \2 referenziert.
:[range]s/old/new/[flags]
# Basic:
:s/old/new/ # replace first 'old' on current line
:s/old/new/g # replace all 'old' on current line
:%s/old/new/g # replace all in whole file
:%s/old/new/gc # confirm each replacement
:%s/old/new/gi # case-insensitive
# Range examples:
:5,10s/old/new/g # lines 5-10
:.,$s/old/new/g # current line to end
:'a,'bs/old/new/g # from mark a to mark b
:'<,'>s/old/new/g # visual selection
:1,$s/old/new/g # whole file (same as %)
# Replace with capture groups:
:%s/\(\w\+\),\(\w\+)/\2,\1/ # swap two comma-separated words
:%s/\v(\w+),(\w+)/\2,\1/ # same with very-magicSubstitute-Flags & besondere Ersetzung
Häufige Flags: g (alle), c (bestätigen), i (schreibunabhängig), n (nur zählen). & in der Ersetzung fügt den gematchten Text ein. \u/\U/\l/\L ändern die Schreibweise der Ersetzung. \r, um einen Zeilenumbruch einzufügen (\n ist in der Ersetzung ein Nullbyte). Das 'n'-Flag ist super, um Matches zu zählen, ohne etwas zu ändern.
# Flags:
g # all occurrences on each line (not just first)
c # confirm each substitution
i # ignore case
I # don't ignore case
e # don't error if no match
p # print last substituted line
n # count matches, don't substitute
# Special chars in replacement:
& # the matched text
\0 # the matched text (same as &)
\1..\9 # capture groups
\u # next char uppercase
\U # rest of string uppercase (until \e or \E)
\l \L # lowercase (single / until \e)
\r # split into new line
\n # null byte (use \r for newline)
# Examples:
:%s/foo/&bar/g # foo -> foobar
:%s/\v(\w+)/\U\1/g # uppercase every word
:%s/, /,\r/g # split lines on ', '
:%s/old/new/gn # count matches onlyGlobaler Befehl (:g)
:g führt einen Ex-Befehl auf jeder Zeile aus, die ein Muster matcht — ein mächtiger 'globaler' Editor. :v (oder :g!) läuft auf nicht-treffenden Zeilen. Mit jedem Ex-Befehl kombinieren: d (löschen), m (verschieben), t (kopieren), s (substituieren), normal (Normalmodus-Befehl ausführen). Nützlich für Batch-Operationen auf markierten Zeilen. Die Reihenfolge zählt: :g verarbeitet standardmäßig von oben nach unten.
:[range]g/pattern/cmd # run cmd on each matching line
:[range]g!/pattern/cmd # run cmd on NON-matching lines
:v/pattern/cmd # same as :g! (inverse)
# Common uses:
:g/^$/d # delete all blank lines
:g/TODO/d # delete all lines with TODO
:g/pattern/p # print all matching lines
:g/pattern/normal @a # run macro a on each matching line
:g/pattern/m0 # move matching lines to top (reverse order)
:g/pattern/t$ # copy matching lines to end
:g/pattern/s/old/new/g # substitute on matching lines only
# Combined with Ex range:
:g/^#/s/foo/bar/g # in lines starting with #, replace foo with bar
# Multiple commands per match:
:g/pattern/d|t0 # delete then copy (chained with |)Visual-Modus
Visual-Modus-Typen
v/V/Ctrl-v wählen Zeichen/Zeilen/Block. gv wählt die letzte visuelle Auswahl erneut — praktisch, um eine Operation erneut anzuwenden. o springt ans andere Ende der Auswahl (Erweiterung in beide Richtungen also möglich). Bei Blockweise bewegt O zur anderen Ecke derselben Zeile.
v # charwise visual (select characters)
V # linewise visual (select whole lines)
Ctrl-v # blockwise visual (select rectangle)
gv # reselect last visual selection
# In visual mode:
o / O # move cursor to other end of selection (corner for block)
Esc / v # exit visual mode (toggle)
# Quick selections from normal mode:
vap # select around paragraph
vip # select inside paragraph
i" # then press v... actually ciw etc. work directly
# Switching between types:
# v then V -> linewise (extends to whole lines)
# V then v -> charwise
# Ctrl-v -> blockwiseVisual-Operationen
Mit einer Auswahl arbeiten d/c/y/x wie erwartet. = rückt automatisch ein (super zum Neformatieren von Code). >/< rücken um eine shiftwidth ein/aus. ! pipet die Auswahl durch einen Shell-Befehl und ersetzt sie durch die Ausgabe. : im Visual-Modus zu drücken füllt '<,'> als Bereich automatisch, :s/old/new/g läuft also nur auf der Auswahl.
# In visual mode, press:
d / x # delete selection
c / s # change selection (delete, enter insert)
y # yank (copy) selection
~ # toggle case of selection
u / U # lowercase / uppercase selection
> # indent selection
< # dedent selection
= # auto-indent selection (reformat)
!cmd # filter through external command
:r !cmd # (after yank) paste command output
# Replace entire selection with a char:
r{x} # replace every char with x
# Print line numbers of selection:
g Ctrl-g # count words/chars/lines in selection
# Search within selection (after selecting, type :):
# '<,'>s/old/new/g -- range auto-filledVisual-Block-Tricks
Der Visual-Block (Ctrl-v) ist eines der mächtigsten Vim-Features. I und A fügen vor/nach dem Block ein — der Text wird nach Esc auf jede Zeile repliziert. Der einfachste Weg, mehreren Zeilen ein Kommentar-Präfix zu ergänzen oder ein Suffix anzuhängen. c ändert den ganzen Block; r{x} ersetzt jedes Zeichen durch x. Blockbearbeitungen funktionieren nur sauber, wenn Zeilen ähnlich lang sind.
# Enter block visual: Ctrl-v
# Select a column rectangle, then:
I # insert BEFORE block (text typed appears in front)
# Type text, then Esc -> inserted on every line of block
A # insert AFTER block (text appears at end of each line)
# Esc propagates the insert to all lines
c # change block (delete, enter insert; Esc propagates)
r{x} # replace every char in block with x
# Common use cases:
# 1. Add a comment to a column of lines:
# Ctrl-v select first column, I, type '# ', Esc
# 2. Add semicolons at end of selected lines:
# Ctrl-v select end column, $A;, Esc
# 3. Delete a column:
# Ctrl-v select, d
# 4. Replace a column with same char:
# Ctrl-v select, r;Visual-Line-Modus
V wählt ganze Zeilen. Nach V sind übliche Operationen d/y/>/</=, um sie zu manipulieren. :m verschiebt die Auswahl (z. B. :'<,'>m0 an den Anfang). :t dupliziert. '< und '> sind Marks am Anfang/Ende der letzten visuellen Auswahl — nützlich in Skripten. gv wählt den letzten visuellen Bereich erneut.
V # enter linewise visual
5V # select 5 lines (current + 4 below)
ggVG # select entire file
:'<,'> # range referring to last visual selection
# After selecting lines (V), useful commands:
d # delete lines
y # yank lines (linewise)
> # indent lines
< # dedent lines
= # auto-indent lines
:m +2 # move selection down 2 lines
:m -3 # move selection up 3 lines
:t . # duplicate lines (copy below selection)
:g/^/m0 # reverse line order (whole file)
# Reselect last visual:
gv # reselect last visual selection
'< # mark: start of last visual
'> # mark: end of last visualVisual mit Text-Objekten
Text-Objekte funktionieren auch im Visual-Modus — sie erweitern die aktuelle Auswahl. vi( wählt innerhalb der Klammern; va( schließt sie ein. Ein Text-Objekt zu wiederholen (vawaw) erweitert weiter. Oft schneller als manuelle Cursorpositionierung. Mit Operatoren kombinieren: ciw ändert das innere Wort, egal wo im Wort der Cursor steht.
# In visual mode, text objects EXTEND the selection:
# After pressing v (charwise), type:
aw # extend selection to include next 'a word'
iw # extend selection to inner word
ab # around brackets ()
ib # inside brackets ()
aB # around braces {}
iB # inside braces {}
a" # around double-quoted string
i" # inside double-quoted string
ap # around paragraph
ip # inside paragraph
# Repeated text objects extend selection:
# vaw -> select word + trailing space
# vawaw -> extend to next word + space
# Switch between inner and around:
# vi( -> select inside parens
# va( -> extend to include the parensVisual-Suche & Nummerierung
: im Visual-Modus zu drücken füllt '<,'> als Bereich vor — Substitutionen laufen also nur auf der Auswahl. Um die visuelle Auswahl zu suchen, y/ dann Ctrl-r " Enter nutzen (Register in die Suche einfügen). g Ctrl-a im Visual-Block erzeugt eine laufende Sequenz — unbezahlbar, um aus einer Spalte identischer Zahlen nummerierte Listen (1, 2, 3, ...) zu erzeugen.
# Search within visual selection:
# 1. Visually select (v/V/Ctrl-v)
# 2. Press : -> :'<,'> appears
# 3. Type s/old/new/g -> substitute only in selection
# Search for current visual selection (forward):
# In visual mode, type:
# \V then / (very-nomagic, escapes regex chars)
# Or use a plugin (e.g. vim-visual-star-search)
# Manual method:
# y/ then Ctrl-r " Enter -> search for selection
# Increment/decrement numbers (visual block):
# Select a column of numbers (Ctrl-v)
Ctrl-a # increment every number in selection by 1
Ctrl-x # decrement every number in selection by 1
g Ctrl-a # increment with running counter (1,2,3,...)
g Ctrl-x # decrement with running counter
# Example: turn 0,0,0,0 into 1,2,3,4:
# Ctrl-v select column, g Ctrl-aBuffers
Buffer-Grundlagen
Buffers sind Dateien im Speicher. :e öffnet eine Datei in einem neuen Buffer. :ls listet alle Buffer mit Statusflags (% = aktuell, # = alternativ, + = geändert, h = verborgen). :b N wechselt nach Nummer; :b name nach eindeutigem Präfix. Ctrl-6 (oder :b#) schaltet zwischen aktuellem und alternativem Buffer um — extrem üblich.
:e file.txt # open file in new buffer (current window)
:enew # new empty buffer
:ls / :buffers # list all buffers
:b N # go to buffer N (by number from :ls)
:b name # go to buffer by name (unique prefix)
:bn # next buffer
:bp # previous buffer
:b# / Ctrl-6 # alternate buffer (last edited)
:ball # open all buffers in horizontal splits
:vertical ball # open all buffers in vertical splits
# Buffer list symbols:
# % current window's buffer
# # alternate buffer
# a active (loaded and visible)
# h hidden (loaded but not visible)
# - not modifiable
# = read-only
# + modifiedBuffer-Navigation
:bn/:bp zyklieren durch Buffer. Ctrl-6 schaltet zwischen den zwei letzten um — der schnellste Weg hin und her. Mit gesetztem 'hidden' erzwingt das Wechseln weg von einem geänderten Buffer kein Speichern — Vim verbirgt ihn stattdessen. :ls und dann :b N, wenn du Buffer-Nummern vergisst. Plugins wie fzf.vim machen fuzzy Buffer-Wechsel viel schneller.
:bn / :bnext # next buffer (wraps around)
:bp / :bprev # previous buffer
:bf / :bfirst # first buffer
:bl / :blast # last buffer
:b# # alternate buffer (Ctrl-6)
:N b # go to buffer number N (e.g. 3b)
:b name<tab> # tab-complete buffer name
:ls then :b N # two-step navigation
# Faster navigation (set in vimrc):
:nmap <C-n> :bn<CR>
:nmap <C-p> :bp<CR>
# Jump to a buffer with fuzzy matching (with fzf.vim):
:Buffers # fuzzy-select from buffer list
# Hide current buffer without saving (if 'hidden' is set):
:hide # or :bn with 'set hidden'Buffer-Operationen
:bd entfernt einen Buffer aus der Liste (die Datei wird geschlossen). :bw wischt zusätzlich Marks und buffer-lokale Variablen. :%bd | e# löscht alle außer dem aktuellen Buffer — ein übliches Aufräummuster. :bufdo führt einen Ex-Befehl in jedem Buffer aus — mächtig für globale Substitutionen, aber auf Fehler achten (mit ! ignorieren oder dem :s das 'e'-Flag ergänzen).
:bd / :bdelete # delete current buffer
:bd N # delete buffer N
:bd name # delete buffer by name
:bw / :bwipeout # wipe buffer (also clears marks, vars)
:N,N bd # delete buffers in range
:%bd # delete all buffers
:%bd | e# # delete all but current
:bn! # force switch (don't save current)
:wall # write all buffers
:bufdo cmd # run cmd in every buffer
:bufdo! cmd # same but ignore errors
# Useful patterns:
:bufdo %s/old/new/ge # substitute in all buffers
:bufdo setlocal nowrap # apply setting to all buffers
# Save and quit current buffer:
:wq # write current and quit (closes window)Verborgene Buffer
Mit 'set hidden' (sehr empfohlen) kannst du dich von geänderten Buffern wegbewegen, ohne zu speichern — Vim hält sie im Speicher. Ohne 'hidden' blockiert Vim das Wechseln, bis du speicherst oder mit ! verwirfst. :ls zeigt 'h' für verborgene Buffer und '+' bei Änderungen. Diese Einstellung ist essenziell für produktives Mehrdateien-Bearbeiten.
:set hidden # allow switching from modified buffers
:set nohidden # force save/abandon when switching
# With 'hidden' set:
# :bn # switch even if current is modified (no save)
# :q # if buffer is modified, prompts to save
# :qa! # quit all without saving
# :wa # write all (hidden + visible)
# Buffer with changes still in memory:
:ls # shows 'h' flag for hidden, '+' for modified
# Recover list of hidden buffers:
:ls h # only hidden buffers
# Save a hidden buffer:
:w # save current (if visible)
:N w # save buffer N
:wall # save all buffers
# Common workflow with hidden:
# :e file1 -> make changes -> :e file2 -> :e file1 (changes preserved)Argumentliste
Die Arglist ist eine eigene Liste neben der Buffer-Liste — die Menge der per Befehlszeile übergebenen oder mit :args gesetzten Dateien. :n/:prev navigieren sie. :argdo führt einen Ex-Befehl in jeder Arglist-Datei aus — perfekt für Batchverarbeitung wie :argdo %s/foo/bar/ge | update. Die Arglist ist oft fokussierter als die Buffer-Liste.
# Open files in arglist:
vim file1.txt file2.txt # initial args
:args file1 file2 file3 # replace arglist
:argadd file4 # add to arglist
:arga *.py # add all Python files
:argdelete file2 # remove from arglist
# Navigate arglist:
:n / :next # next file in arglist
:prev / :Next # previous file
:first # first file
:last # last file
:rewind # rewind to first file
# Process all files:
:argdo %s/old/new/ge # substitute in every arg file
:argdo set ff=unix | w # convert line endings in all
# Show current arglist:
:args # show files (current marked with [ ])Buffer-Listenverwaltung
:ls listet Buffer, :ls! schließt ungelistete ein (gelöscht, aber gemerkt). :sb nutzen, um einen Buffer in einem Split zu öffnen, ohne den Buffer des aktuellen Fensters zu ändern. Ein eingebautes 'kürzlich geschlossener Buffer'-Undo gibt es nicht, aber Plugins existieren. :bufdo vimgrepadd gefolgt von :copen erlaubt die Suche über alle offenen Buffer via die Quickfix-Liste.
:ls # list all buffers
:ls! # list including unlisted buffers
:files # alias for :ls
# Move current buffer to a specific position:
:N b N # buffer number N
# Quickly inspect related files:
:b <tab> # tab-complete buffer names
:b #<tab> # buffers matching '#'
# Find buffer containing a pattern:
:vimgrep /pattern/ % # current buffer only
:bufdo vimgrepadd /pattern/ % # all buffers (then :copen)
# Open buffer in a specific window:
:sb N # open buffer N in horizontal split
:vertical sb N # open buffer N in vertical split
:tab split +b N # open buffer N in new tab
# Restore closed buffers:
# (No built-in, but plugins like vim-molten or
# vim-restore-buffers can help)Marks & Sprünge
Marks setzen
Marks sind benannte Positionen in Dateien. Kleinbuchstaben (a-z) sind buffer-lokal; Großbuchstaben (A-Z) sind Datei-Marks, die über Vim-Sessions hinweg bestehen. Nummerierte Marks (0-9) werden automatisch gesetzt — 0 ist die Position beim letzten Vim-Ende, 1-9 sind zuletzt geschlossene Dateien. :marks listet sie, :delm löscht.
m{a-zA-Z} # set mark at cursor position
ma # set mark 'a' (lowercase, buffer-local)
mA # set mark 'A' (uppercase, file mark)
m' # set the unnamed mark (jump before/after)
# Lowercase marks (a-z):
# Local to current buffer
# Lost when buffer is unloaded
# Uppercase marks (A-Z):
# File marks — preserved across sessions
# Work even after the file is closed
# Numbered marks (0-9):
# Set automatically by Vim
# 0 = position when Vim was last closed
# 1-9 = positions of last 9 closed files
# View marks:
:marks # list all marks
:marks a b c # specific marks
:delm! a # delete mark 'a' (force)Zu Marks springen
` (Backtick) springt zur exakten Position (Zeile + Spalte); ' (Apostroph) zum ersten Nicht-Leerzeichen der markierten Zeile. `A öffnet die Datei mit Mark A, selbst wenn sie geschlossen war. `. springt dorthin, wo du zuletzt Text ändertest, `[ und `] begrenzen den zuletzt yank-/gelöschten Bereich, `< und `> die letzte visuelle Auswahl.
\`{a-zA-Z} # jump to mark (line AND column)
'{a-zA-Z} # jump to mark (line only, column 1)
\`a # jump to mark 'a' (exact position)
'a # jump to line of mark 'a'
\`A # jump to file mark 'A' (opens file if closed)
\`. # jump to position of last change in this buffer
\`" # jump to position when file was last closed
\`[ # jump to start of last yanked/changed text
\`] # jump to end of last yanked/changed text
\`< # jump to start of last visual selection
\`> # jump to end of last visual selection
\`^ # jump to last insert position (also gi)
# Jump to next/prev mark in alphabetical order:
:[count]next # (no built-in, requires plugin)Jumplist
Vim hält eine Jumplist bedeutender Cursorbewegungen. Ctrl-o/Ctrl-i bewegen sich darin zurück/vorwärts. 'Bedeutend' heißt Sprünge (G, gg, Suche, Mark-Sprünge, Tag-Sprünge) — nicht reguläre Motions wie j/k/w. :jumps zeigt die Liste. Die Jumplist ist pro Fenster und persistiert über Sessions in viminfo/shada.
Ctrl-o # jump BACK in jumplist (older positions)
Ctrl-i # jump FORWARD in jumplist (newer positions)
Tab # same as Ctrl-i
:ju # show jumplist (:jumps)
# What counts as a jump?
# - Movement commands: G, gg, H, M, L, %
# - Search: /, ?, n, N, *, #
# - Mark jumps: 'x, `x (NOT mm)
# - Buffer switch: Ctrl-6, :b, :e
# - Tag jumps: Ctrl-]
# NOT counted: j, k, w, b, h, l (regular motions)
# Max jumplist size: 100 entries by default
:set jumpoptions=stack # treat jumplist like a stack
# Clear jumplist:
:clearjumps # or :cljChangelist
Die Changelist trackt Bearbeitungspositionen (keine Navigation). g; springt zur vorherigen Bearbeitung, g, zur nächsten. Nützlich, um deine Änderungen zurückzuwandern: 'Wo war ich gerade?'. :changes zeigt die Liste. Anders als die Jumplist ist die Changelist pro Buffer. Mit `.` kombinieren für die allerletzte Änderung im aktuellen Buffer.
g; # go to OLDER position of last change
g, # go to NEWER position of last change
:changes # list changelist
# Each entry shows:
# change number, line, column, text of change
# What counts as a change?
# - Any insertion, deletion, or substitution
# - Records the position BEFORE the change
# Differences from jumplist:
# - Changelist tracks EDITS, not movements
# - Per-buffer (not per-window)
# - Limited to 100 entries
# Combine with marks:
\`. # last change position in current buffer
g; # previous change position
# Common pattern: g;g;g; to walk back through editsDatei-Marks (A-Z)
Großbuchstaben-Marks (A-Z) sind Datei-Marks — sie merken sich Datei UND Position und bestehen über Vim-Sessions hinweg (in viminfo gespeichert). mA in foo.txt zu setzen erlaubt die Rückkehr zu dieser Position von überall mit `A, selbst nach Vim-Neustart. Als Lesezeichen für wichtige Dateien/Positionen in einem Projekt nutzen.
# Setting a file mark:
mA # set mark 'A' at cursor (in current file)
mB # set mark 'B' (in current file)
# Jumping to a file mark:
\`A # if file is open: jump to position
\`A # if file is closed: open it, then jump
'A # jump to first non-blank of mark's line
# File marks persist across Vim sessions:
# Stored in viminfo (or shada in Neovim)
# Restored on next Vim launch
# Use cases:
# 1. Bookmark a function: mA in function definition
# 2. Quick jump between files: `A, `B
# 3. Project navigation: set marks in important files
# Listing file marks:
:marks A-Z # show only file marks
# Deleting:
:delm A # delete file mark A (must be in its file)Eingebaute besondere Marks
Vim setzt besondere Marks automatisch. `.` ist die letzte Änderung, `[ und `] begrenzen den zuletzt yank-/gelöschten Bereich, `< und `> die letzte visuelle Auswahl, `^ ist, wo der Insert-Modus zuletzt endete (gi springt dorthin und geht wieder in den Insert-Modus). `" ist die Position beim letzten Schließen der Datei — nützlich, um die Arbeit fortzusetzen.
\`. # position of last change in current buffer
\`" # position when file was last exited
\`[ # start of last yanked/changed text
\`] # end of last yanked/changed text
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # position where insert mode was last stopped
\`' # position before latest jump (where you came FROM)
# Common uses:
\`[\`] # operate on last yanked range: \`[v\`]U (uppercase it)
\`<\`> # re-select last visual: \`<v\`> or gv
# Re-select last visual selection:
gv # easier than \`<v\`>
# Re-select last pasted text:
\`]v\`[ # or use a mapping: nnoremap gp \`]v\`[
# Return to last insert position:
gi # jump to `^ and enter insert modeText-Objekte
Wort- & Satz-Objekte
Text-Objekte erlauben Operationen auf semantischen Einheiten. 'aw' (around word) schließt nachgestellten Whitespace ein — daw schließt die Lücke. 'iw' (inner word) lässt Whitespace intakt — diw lässt eine Lücke. as/ap sind die Satz-/Absatz-Versionen. Ein Objekt zu wiederholen (dawaw) erweitert die Auswahl. Am nützlichsten mit d/c/y/v-Operatoren.
# Operators (d/c/y/v) + text object:
aw # 'a word' - word + trailing whitespace
iw # 'inner word' - word only (no whitespace)
aW # 'a WORD' - WORD + trailing whitespace
iW # 'inner WORD' - WORD only
as # 'a sentence' - sentence + trailing space
is # 'inner sentence' - sentence only
ap # 'a paragraph' - paragraph + trailing blank line
ip # 'inner paragraph' - paragraph only
# Examples:
daw # delete word + trailing space (closes gap)
diw # delete word only (leaves whitespace)
cas # change sentence (with trailing space)
yap # yank paragraph (with trailing blank line)
gqip # format (wrap) inner paragraph
# Repeated: dawaw extends to next wordKlammer-Objekte
Klammer-Objekte arbeiten auf (), [], {}, <>. a (around) schließt die Klammern ein; i (inner) schließt sie aus. ci( ändert den Inhalt der Klammern, ohne sie zu entfernen — perfekt zum Bearbeiten von Funktionsargumenten. Bei Verschachtelung wirkt es auf das innerste Paar. at/it arbeiten auf HTML-/XML-Tags (cit ändert z. B. inneren Tag-Inhalt).
# Brackets (any of ( [ { <):
ab / ib # around / inside ()
aB / iB # around / inside {} (also a{ / i{)
a( / i( # same as ab / ib
a[ / i[ # around / inside []
a{ / i{ # same as aB / iB
a< / i< # around / inside <>
# Examples:
ci( # change text inside ( ... )
daB # delete {...} block including braces
yi[ # yank text inside [...]
vaB # visually select around {...}
# Special: 'tag' objects (HTML/XML):
at / it # around / inside <tag>...</tag>
# Tip: works with mismatched brackets too:
# ci) on (foo bar) changes 'foo bar'
# Nested: ci( in ((a)(b)) changes innermostAnführungszeichen-Objekte
Anführungszeichen-Objekte (a"/i", a'/i', a`/i`) arbeiten auf quotierten Strings. Der Cursor muss nicht innerhalb der Anführungszeichen sein — Vim findet das nächste Paar. ci" ändert den Inhalt eines Strings, ohne die Anführungszeichen zu entfernen — unbezahlbar zum Bearbeiten von String-Literalen. Mit 'a' einschließen, mit 'i' ausschließen.
a" # around double-quoted string (includes quotes)
i" # inside double-quoted string (no quotes)
a' # around single-quoted string
i' # inside single-quoted string
a\` # around backtick-quoted string
i\` # inside backtick-quoted string
# Examples:
ci" # change text inside "..."
da" # delete "..." (including quotes)
yi' # yank text inside '...'
va\` # visually select around \`...\`
# Cursor can be ANYWHERE on the line — Vim finds the
# nearest quote pair containing or following the cursor.
# Special: with counts
3a" # around 3 consecutive quoted strings
# Tip: ci" when cursor is on the quote itself works tooSatz- & Absatz-Objekte
Sätze enden mit . ! ? gefolgt von Whitespace (oder Absatzbruch). Absätze sind durch Leerzeilen getrennte Blöcke. 'a' schließt nachgestellten Whitespace ein, 'i' schließt ihn aus. Nützlich mit Operatoren: gqap formatiert einen Absatz neu, >ip rückt ihn ein, das löscht einen Satz. Die Motions ( und ) springen zwischen Sätzen.
# Sentence: ends with . ! ? followed by whitespace
as / is # around / inner sentence
# Paragraph: blocks of text separated by blank lines
ap / ip # around / inner paragraph
# Examples:
das # delete a sentence
cip # change inside paragraph
vap # select around paragraph (with trailing blank)
# Differences:
# 'a' (around): includes trailing whitespace/blank line
# 'i' (inner): no trailing whitespace
# Use cases:
# gqap # reformat (wrap) the paragraph
# >ap # indent the paragraph
# vip # select inside paragraph
# :'<,'>s/old/new/g # substitute in selected paragraph
# Sentence motion commands (not objects):
( # previous sentence start
) # next sentence startTag- & URL-Objekte (mit Plugins)
Eingebaute at/it arbeiten auf HTML-/XML-Tags. cit ändert inneren Tag-Inhalt, dat löscht den ganzen Tag inklusive Öffnen/Schließen. Bei verschachtelten Tags wählt it das innerste, dann erweitert vat nach außen. Plugins ergänzen weitere Objekte: vim-textobj-url (au/iu), vim-indent-object (ai/ii für Blöcke gleicher Einrückung — exzellent für Code).
# Built-in tag object (HTML/XML):
at / it # around / inside <tag>...</tag>
# Examples:
cit # change inner tag text: <p>text</p> -> <p>|</p>
dat # delete entire tag: <p>text</p> -> (gone)
vit # visually select inner tag text
yat # yank entire tag including <tag>...</tag>
# For nested tags, 'it' selects the innermost:
# <div><p>text</p></div>
# cit on 'text' changes 'text' only
# vat extends selection outward
# URL objects (require a plugin like vim-textobj-url):
# au / iu # around / inside URL
# Indent objects (require vim-indent-object):
# ai / ii # around / inside same-indent block
# aI / iI # entire indentation level
# Common plugin combos:
# vai # select around indent block (great for code)Text-Objekte nutzen (Rezepte)
Text-Objekte kombinieren sich mit jedem Operator (d/c/y/v/>/</=) für mächtige Bearbeitungen. ciw ändert ein Wort, ohne dass du den Cursor exakt positionieren musst. ci"/ci(/ci[ ändern innerhalb von Anführungszeichen/Klammern. gqip formatiert Absätze neu. Diese zu beherrschen ist der Schlüssel, um in Vim mit Gedankengeschwindigkeit zu bearbeiten.
# Common editing recipes using text objects:
# Word:
ciw # change word (regardless of cursor position in it)
daw # delete word + space (closes gap)
yiw # yank inner word (no whitespace)
# Quotes:
ci" # change inside "..."
ci'\` # change inside '...' or \`...\`
da" # delete the entire string (with quotes)
# Brackets:
ci( # change inside (...) -- great for args
daB # delete {...} block (function body)
ci[ # change inside [...]
# Sentences & paragraphs:
cas # change a sentence
dap # delete a paragraph
gqip # reformat paragraph
# HTML tags:
cit # change tag content
vat # select tag, then vat again to extend
# Combos with counts:
2daw # delete two words
c2aw # change two wordsRegister
Register-Grundlagen
Register sind Vims Zwischenablagen. "ayy yankt eine Zeile in Register a, "ap fügt aus a ein. Es gibt viele Register: benannte (a-z), Anhänge (A-Z), nummerierte (1-9) und besondere (unbenannt ", yank 0, Clipboard + usw.). :reg listet sie. Im Insert-Modus fügt Ctrl-r {reg} ein Register ein. Großbuchstaben HÄNGEN an ein Register an.
# Registers store text. 10 named (a-z), 10 append (A-Z),
# 9 numbered (1-9), and several special ones.
"ay # yank into register 'a' (then motion: "ayy, "ayw)
"ap # paste from register 'a'
"ad # delete into register 'a' (e.g. "add)
"Ay # APPEND to register 'a' (uppercase = append)
# View all registers:
:reg # list all registers
:reg a b c # list specific registers
:reg + # show clipboard register
# Use a register with operators:
"aD # delete to end of line into 'a'
"byy # yank line into 'b'
"cp # paste register 'c'
# Insert mode: Ctrl-r + register
Ctrl-r a # insert contents of register 'a'
Ctrl-r = # expression register (compute, insert)
# Search from a register:
/ then Ctrl-r a # search register 'a' contentsBenannte & nummerierte Register
Benannte Register (a-z) sind nutzergesteuert; A-Z hängt an a-z an. Nummerierte Register (1-9) verfolgen Löschungen automatisch — 1 ist die jüngste, jede neue Löschung verschiebt sie nach unten. Register 0 hält nur den letzten YANK (Löschungen überschreiben ihn nicht) — nützlich für yank-then-delete-Workflows. "- hält kleine (sub-line-)Löschungen.
# Named registers (a-z, A-Z):
"ayy # yank line into 'a'
"byiw # yank inner word into 'b'
"Ayy # append yanked line to 'a' (uppercase)
# Numbered registers (1-9) — auto-filled by deletes:
"1 # last delete (largest)
"2 # second-to-last delete
... # shift older with each new delete
"9 # oldest tracked delete
# Small delete register:
"- # stores deletes < 1 line (e.g. dw)
# Yank register (separate from deletes):
"0 # last YANK only (not affected by deletes)
# Examples:
"0p # paste last yank (won't paste a delete)
"1p # paste last delete
". # last inserted text (read-only)
"% # current file name (read-only)Besondere Register
Besondere Register: ". = zuletzt eingefügter Text, "% = aktuelle Datei, "/ = letzte Suche, ": = letzter Befehl. "_ ist das schwarze Loch — hinein Geschriebenes wird verworfen (nützlich für Löschungen, die andere Register nicht verschmutzen sollen). "+ ist die Systemzwischenablage, "* ist die X11-Primärauswahl. "= wertet einen Vimscript-Ausdruck aus und fügt das Ergebnis ein.
# Read-only registers:
". # last inserted text
"% # current file name
"# # alternate file name
": # last Ex command
"/ # last search pattern
# Read/write registers:
"0 # last yank (not overwritten by deletes)
"- # last small delete (less than one line)
"_ # black hole register (discard, like /dev/null)
"= # expression register (evaluate Vimscript)
# Clipboard / selection:
"+ # system clipboard (Ctrl-C / Ctrl-V)
"* # primary selection (X11 middle-click)
# Examples:
"_dd # delete line without saving to register
"+y # yank to system clipboard (then Ctrl-V elsewhere)
"*p # paste from X11 primary selection
# Expression register (in insert mode):
Ctrl-r =strftime('%Y-%m-%d')<CR>
# inserts today's date
# Black hole: "_ prevents updating other registers.Makros in Registern
Makros leben in Registern — Aufnahme mit qa schreibt Tastenschläge in Register a, @a spielt sie zurück. Weil es Register sind, kannst du sie inspizieren (:reg a), bearbeiten durch Einfügen/Ändern/Zurückyanken oder in deiner vimrc speichern mit :let @a = '...'. Besondere Tasten in String-Literalen mit \<Esc> escapen.
# Macros are stored in registers, just like yanked text.
# Record a macro into register 'a':
qa # start recording into 'a'
... # perform actions
q # stop recording
# Play back the macro:
@a # play macro 'a' once
@@ # play last macro again (the one just played)
5@a # play macro 'a' 5 times
:reg a # view the recorded keystrokes
# Edit a macro:
:let @a = "..." # set register 'a' directly
# Or: paste the register, edit, yank back:
"ap # paste macro keystrokes
# ... edit the text ...
"ayy # yank edited version back into 'a'
# Save a macro to vimrc:
:let @a = "0iHello \<Esc>" # escaped special keys
# Apply macro to a range:
:%normal @a # run macro 'a' on every lineAnhängen & schwarzes Loch
Großbuchstaben-Register HÄNGEN AN: "Ayy hängt an Register a an (sehr nützlich, um Text oder mehrstufige Makros aufzubauen). Das schwarze Loch "_ verwirft alles Hineingeschriebene — Löschungen aktualisieren die nummerierten/unbenannten/yank-Register nicht. Nutzen, wenn du Text löschen willst, ohne deinen letzten Yank zu zerstören.
# Append to a register (use UPPERCASE letter):
"ayy # yank line into 'a'
"Ayy # APPEND another line to 'a'
"Ayiw # APPEND a word to 'a'
# After: register 'a' contains both.
# Black hole register "_:
"_d # delete without affecting other registers
"_dd # delete line, doesn't update "1, "0, "-
"_c # change without saving deleted text
"_x # delete char, nothing saved
# Why use black hole?
# - Keep your yank register ("0) intact while deleting
# - Avoid polluting numbered registers
# Example: yank a line, then delete another (without
# losing the yank):
"ayy # yank into 'a'
"_dd # delete line WITHOUT touching 'a' or '0
"ap # paste the original yank
# When clipboard=unnamed, "_d still bypasses clipboard.Zwischenablage & Auswahl
"+ ist die Systemzwischenablage (Ctrl-C/Ctrl-V in GUI-Apps), "* ist die X11-Primärauswahl (Mittelklick-Einfügen). Mit :set clipboard=unnamedplus gehen Yanks und Einfügungen direkt in die Systemzwischenablage — kein "+-Präfix nötig. Unter Linux brauchst du evtl. xclip/xsel (X11) oder wl-clipboard (Wayland) installiert.
# System clipboard register:
"+y # yank to system clipboard
"+p # paste from system clipboard
"+dd # delete line to clipboard
"+P # paste before cursor from clipboard
# X11 primary selection (Linux, middle-click):
"*y # yank to primary selection
"*p # paste from primary selection
# Make the system clipboard the default:
:set clipboard=unnamedplus # use '+ for unnamed register
:set clipboard=unnamed # use '* for unnamed register
# Then yank/paste go to clipboard automatically:
yy # yanks to system clipboard (with above setting)
p # pastes from system clipboard
# Check what's in the clipboard:
:reg + # show clipboard contents
# On Linux, install a clipboard tool if missing:
# xclip or xsel for X11
# wl-clipboard for WaylandMakros
Makros aufnehmen
q{letter} startet die Aufnahme in ein Register; q erneut drücken zum Stoppen. Die aufgenommenen Tastenschläge lassen sich mit @{letter} wiedergeben. Beim Aufnehmen Motions nutzen, die konsistent funktionieren — 0, ^, $, w, e statt j/k bevorzugen, die von der Spalte abhängen. Vor dem Massenanwenden an ein paar Zeilen testen.
q{a-z} # start recording into register {a-z}
... # perform actions (keystrokes recorded)
q # stop recording
# Example: wrap each word in quotes on a line:
qa # start recording into 'a'
0 # go to first column
i" # insert opening quote
Esc
e # go to end of word
a" # append closing quote
Esc
w # move to next word
q # stop recording
# Now @a will wrap one more word.
# Recording tips:
# - Use 0/^-positioned motions (not j/k)
# - Use commands that work regardless of line length
# - Test on a few lines before applying broadly
# View the recorded macro:
:reg a # see keystrokes in register 'a'Makros abspielen
@a spielt das Makro einmal, @@ das letzte erneut, N@a N-mal. Um ein Makro auf viele Zeilen anzuwenden, sie visuell wählen und :normal @a ausführen, oder :%normal @a für die ganze Datei. Makros stoppen bei Fehlern (etwa wenn eine Suche scheitert), 999@a verarbeitet also sicher bis zum Dateiende. :g/pattern/normal @a läuft nur auf treffenden Zeilen.
@a # play macro 'a' once (in current buffer)
@@ # replay the LAST macro played
5@a # play macro 'a' 5 times
100@a # play 'a' up to 100 times (stops on error)
# Play across multiple lines:
# 1. Visually select lines (V)
# 2. :normal @a # play 'a' on each selected line
# Or:
:%normal @a # play on every line in file
:5,20normal @a # play on lines 5-20
:g/pattern/normal @a # play on lines matching pattern
# Recursive macros:
# If macro 'a' contains @a, it'll recurse.
# Add a 'j' at the end to move to next line.
# Common pattern: process all matching lines:
# qa0f:x...jq # record macro moving down 1 line
# :%s/pattern//gn # count matches
# 100@a # play up to 100 timesMakros bearbeiten
Weil Makros in Registern liegen, kannst du sie bearbeiten. Das Register einfügen ("ap), den Text ändern, dann zurückyanken ("ay$ oder "ayy). Oder :let @a = '...' mit Tasten-Escapes nutzen (\<Esc>, \<CR>). Das ist viel einfacher, als ein komplexes Makro von Grund auf neu aufzunehmen, wenn du einen kleinen Fehler machst.
# Macros are just text in registers — you can edit them.
# Method 1: paste, edit, yank back:
"ap # paste register 'a' into buffer
# ... edit the pasted text (modify keystrokes) ...
0"ay$ # yank the line back into 'a'
# Method 2: set the register directly with :let
:let @a = "0iHello \<Esc>"
# Note: special keys need \<Esc> notation in strings
# Method 3: edit in a scratch buffer:
:edit
"ap # paste macro
# edit
"ayy # yank back to 'a'
:bdelete
# Common edits:
# - Add 'j' at the end to advance to next line
# - Remove a step that you don't need
# - Replace a hard-coded search with a generic one
# Show the macro as keystrokes:
:reg a # view current 'a' contentsRekursive Makros
Rekursive Makros rufen sich selbst auf, bis sie fehlschlagen — typischerweise, wenn eine Suche scheitert. KRITISCH: Das Register vorher leeren (let @a = ''), bevor du aufnimmst, sonst spielt der erste @a-Aufruf im Makro die ALTEN Inhalte. Das Makro terminiert selbst, wenn die fehlschlagende Suche die Rekursion stoppt. Super für globale Suchen-und-Ersetzen-Muster.
# A macro can call itself, enabling recursion.
# Example: change every 'foo' to 'bar' in a column:
# (search-based macro)
# Steps to set up recursive macro 'a':
# 1. Clear register 'a':
:let @a = ''
# 2. Start recording:
qa
# 3. Search for 'foo':
/foo<CR>
# 4. Replace with 'bar' (ciwbar<Esc>):
ciwbar<Esc>
# 5. Call itself:
@a
# 6. Stop recording:
q
# Now @a runs until search fails (no more 'foo').
# The recursion stops automatically on the first error
# (when /foo finds nothing).
# Tip: clear the register first, otherwise the FIRST
# call also replays the old contents of 'a'.
# Run:
@a # processes all 'foo' in fileMakros mit Zählern
N@a spielt das Makro N-mal — bricht aber früh bei jedem Fehler ab, 999@a verarbeitet also sicher bis zum Dateiende. :bufdo normal @a führt das Makro in jedem Buffer aus, :argdo in jeder Arglist-Datei. :g/pattern/normal @a nur auf treffenden Zeilen. Zähler INNERHALB eines Makros (z. B. 5j) wiederholen sich pro Wiedergabe, nicht pro Makro.
# Apply a count to a macro:
5@a # play macro 'a' 5 times
N@a # play up to N times (stops on error)
# Useful: large count to process until end-of-file
999@a # play 'a' up to 999 times (errors stop it)
# Macros with counts INSIDE:
# If your macro starts with '5j', each play jumps 5 lines
# Combine with visual selection (block):
# Ctrl-v to select, then :normal @a
# plays 'a' on each line in the block
# Process every Nth line:
:let i = 0
:g/^/if i % 3 == 0 | normal @a | endif
# (plays 'a' on every 3rd line)
# Apply with a delay (avoid blocking):
# No built-in, but plugins can defer
# Repeat across buffers:
:bufdo normal @a # play 'a' in every buffer
:argdo normal @a # play 'a' in every arg fileMakros über Dateien & Zeilen
:[range]normal @a führt ein Makro auf jeder Zeile im Bereich aus — der häufigste Weg, ein Makro auf viele Zeilen anzuwenden. Dein Makro mit 'j' abschließen, damit jede Iteration zur nächsten Zeile rückt. :bufdo/:argdo führen es über Buffer/Dateien aus. | update ergänzen, um jede geänderte Datei zu speichern. ! nutzen, um über Fehler hinweg fortzufahren (z. B. :bufdo!).
# Apply a macro to every line in a range:
:[range]normal @a
:%normal @a # whole file
:5,20normal @a # lines 5-20
:'<,'>normal @a # visual selection
:g/pattern/normal @a # only matching lines
# Apply across buffers:
:bufdo normal @a # every buffer
:argdo normal @a # every arglist file
# Save modified buffers after macro run:
:argdo normal @a | update # save each that changed
# Best practice: include 'j' (move down) at end of macro
# so it advances to the next line for :normal usage.
# Example macro for processing CSV rows:
# qa 0f,dt,j q # cut field at comma, move down
# :%normal @a # apply to every line
# Abort on error vs. continue:
:bufdo! normal @a # continue even if a buffer errors
# Debug: play macro step-by-step (no built-in, but
# :set lazyredraw off + slow key timing helps).Folding
Fold-Methoden
foldmethod steuert, wie Folds entstehen. 'manual' erlaubt Folds mit zf. 'indent' fold-t automatisch nach Einrückung (super für Code). 'syntax' nutzt Syntaxregeln (sprachbewusst). 'marker' nutzt {{{ }}} im Dateitext. 'expr' für eigene Logik. Manuelle Folds gehen beim Schließen verloren, außer du speicherst sie mit :mkview.
:set foldmethod=manual # fold by hand (zf)
:set foldmethod=indent # fold by indent level
:set foldmethod=expr # fold by 'foldexpr'
:set foldmethod=syntax # fold by syntax rules
:set foldmethod=marker # fold by {{{ }}} markers
:set foldmethod=diff # fold unchanged text in diff
# Recommended defaults:
:set foldmethod=indent # great for code
:set foldlevel=2 # show first 2 levels
# Per-method notes:
# manual - zf to create, zd to delete
# indent - automatic, based on shiftwidth
# syntax - automatic, requires syntax file support
# marker - persistent (saved in file as {{{ }}})
# expr - custom logic via 'foldexpr'
# Persistent manual folds across sessions:
:mkview # save folds (and other view state)
:loadview # restore them
# Or set:
:set viewoptions=folds # what :mkview savesManuelles Folding
Im manuellen Modus erzeugt zf einen Fold (z. B. foldet zf3j die nächsten 3 Zeilen). zd löscht einen Fold, zD rekursiv, zE alle Folds im Fenster. Visual-Modus + zf foldet die Auswahl. Mit foldmethod=marker legst du öffnende und schließende Marker aus je drei geschweiften Klammern in Kommentare, um persistente Folds zu erzeugen, die mit in der Datei gespeichert werden — nützlich, um die Fold-Struktur in der Versionskontrolle zu teilen.
# Manual fold commands (foldmethod=manual):
zf{motion} # create fold over motion (e.g. zf3j)
zF # create fold over current line(s)
zd # delete fold at cursor
zD # delete fold recursively (nested)
zE # eliminate ALL folds in window
zj / zk # move to next/prev fold start
[z / ]z # move to fold start/end
# Select then fold (visual):
V zf # visually select lines, then fold
# Create fold for a range:
:5,20fold # fold lines 5-20
# Fold using a marker (manual mode):
# Place markers in the file (with foldmethod=marker):
function Foo() " {{{
echo "hi"
endfunction " }}}
# When foldmethod=marker, the {{{ }}} create persistent
# folds stored in the file text itself.Fold-Öffnen-/Schließen-Befehle
zo/zc öffnen/schließen einen Fold; za schaltet um. zO/zC/zA wirken rekursiv auf verschachtelte Folds. zr/zm passen das Fold-Level global an (eine Ebene pro Mal). zR öffnet alles, zM schließt alles — schnelle Wege zum Zurücksetzen. zj/zk springen zwischen Folds, [z/]z an Anfang/Ende des aktuellen Folds.
zo # open fold (one level)
zc # close fold (one level)
za # toggle fold (open <-> closed)
zO # open fold recursively (all levels)
zC # close fold recursively (all levels)
zA # toggle fold recursively
zr # reduce fold level by 1 (open one level everywhere)
zm # increase fold level by 1 (close one level everywhere)
zR # open ALL folds (reduce to level 0)
zM # close ALL folds (fold everything)
# Navigation in/around folds:
zj # next fold start (down)
zk # previous fold end (up)
[z # start of current open fold
]z # end of current open fold
# Move with folds intact (don't open):
# Use j/k normally — they may skip closed folds
# Set 'foldopen' to control what opens foldsFold-Navigation & -Bearbeitung
j/k können geschlossene Folds überspringen, je nach 'foldopen'. zj/zk navigieren zwischen Fold-Grenzen. yy/dd auf einer gefoldeten Zeile wirken auf ALLE gefoldeten Zeilen als Einheit (linewise). Tippen innerhalb eines geschlossenen Folds öffnet ihn. 'foldopen' konfigurieren, um zu steuern, welche Motions Folds öffnen (z. B. 'search' entfernen, um Folds bei der Suche geschlossen zu halten).
# Fold-related motions:
zj # next fold start (move down)
zk # previous fold end (move up)
[z # start of current open fold
]z # end of current open fold
# What opens a fold when triggered?
:set foldopen=block,hor,mark,percent,quickfix,
search,tag,undo
# Defaults open folds on most motions.
# To make j/k NOT open folds:
:set foldopen-=block
# Editing a closed fold:
# Typing inside a closed fold opens it.
# 'o' or 'O' on a fold line opens a new line.
# Search inside closed folds:
# Default behavior depends on 'foldopen'.
# :set foldopen-=search # don't open on search
# Yank/paste on folded lines:
# yy yanks ALL lines in the fold (linewise)
# dd deletes ALL lines in the fold
# Paste over a fold:
# p with a linewise register replaces the folded regionFold-Optionen
foldlevel steuert, wie tief Folds offen bleiben (höher = mehr offen). foldlevelstart=99 startet mit allem offen. foldcolumn zeigt eine Seitenleiste mit Fold-Zustandsindikatoren. foldminlines verhindert winzige Folds. Um Folds über Sessions hinweg zu persistieren, :mkview auf BufWinLeave und :loadview auf BufWinEnter — ein übliches autocmd-Muster.
:set foldmethod=indent # folding method
:set foldlevel=2 # show folds deeper than this
:set foldlevelstart=99 # start with all folds open
:set foldminlines=3 # min lines to form a fold
:set foldcolumn=4 # 4-char column showing fold state
:set foldenable # enable folding (default on)
:set foldclose=all # auto-close folds when cursor leaves
:set foldopen=block,hor,mark,percent,quickfix,search,tag,undo
:set foldtext=foldtext() # text to show on a closed fold
:set fillchars=fold:\ , # chars for fold display
# Common combo for code:
:set foldmethod=indent
:set foldlevelstart=10
:set foldnestmax=10 # max nesting depth
# Custom fold text:
:set foldtext=MyFoldText()
function MyFoldText()
return '+++ ' . (v:foldend - v:foldstart + 1) . ' lines +++'
endfunction
# Persistent folds across sessions:
:set viewoptions=folds,cursor
:autocmd BufWinLeave * mkview
:autocmd BufWinEnter * silent loadviewVerschachtelte Folds & Fold-Level
Folds verschachteln hierarchisch. 'foldlevel' bestimmt die tiefste offene Ebene — foldlevel=0 schließt alles, 99 öffnet alles. zr/zm passen um 1 an, zR/zM sind die Extreme. 'foldnestmax' begrenzt die Verschachtelungstiefe, um außer Kontrolle geratene Folds in tief verschachteltem Code zu vermeiden. Eigene foldtext-Funktionen erlauben es zu steuern, was auf einem geschlossenen Fold erscheint.
# Folds can nest. 'foldlevel' controls which are open:
:set foldlevel=0 # all folds closed
:set foldlevel=1 # only top-level open
:set foldlevel=99 # all open
# Display current fold level:
:echo &foldlevel
# Increase/decrease by 1:
zr # reduce (open one level everywhere)
zm # more (close one level everywhere)
zR # open ALL folds (set foldlevel to 99)
zM # close ALL folds (set foldlevel to 0)
# Limit nesting:
:set foldnestmax=10
# Each indent level adds a fold level.
# Useful for deeply-nested code:
# function outer() {
# function inner() { <- foldlevel 2
# function deep() { <- foldlevel 3
# }
# }
# }
# Custom foldtext for nested folds:
:set foldtext=NeatFoldText()
function! NeatFoldText()
let line = getline(v:foldstart)
let n = v:foldend - v:foldstart + 1
return line . ' (' . n . ' lines)'
endfunctionGeteilte Fenster
Fenster teilen
:split/:vsplit teilen das aktuelle Fenster — beide zeigen standardmäßig denselben Buffer (Änderungen synchronisieren sich). :split file öffnet eine Datei in einem neuen Split. :new/:vnew erzeugen leere Buffer. Ctrl-w s/v sind die Tastenkürzel. Ein Zahlenpräfix setzt die Größe des neuen Fensters (:10split erzeugt ein 10-zeiliges Fenster).
:split / :sp # horizontal split (current file)
:vsplit / :vs # vertical split (current file)
:split file.txt # split + open file
:vsplit file.txt # vsplit + open file
:new # horizontal split with empty buffer
:vnew # vertical split with empty buffer
:5split / :5vsplit # split with 5 rows/cols
# Quick splits (Normal mode):
Ctrl-w s # split horizontally (same as :split)
Ctrl-w v # split vertically (same as :vsplit)
Ctrl-w n # new horizontal split (empty)
Ctrl-w q # close window (same as :q)
# Split with size hints:
:10split file.txt # split with height 10
:vert 30split file # vertical split with width 30
# Reopen current file in a new split:
Ctrl-w s # same buffer, two views (sync scroll optional)Fensternavigation
Ctrl-w gefolgt von h/j/k/l navigiert zwischen Fenstern (Eselsbrücke: hjkl wie Bewegung). Ctrl-w w zykliert zum nächsten Fenster. Für Tempo mappen viele Nutzer Ctrl-h/j/k/l direkt auf die Fensternavigation. Ctrl-w p kehrt zum zuvor genutzten Fenster zurück — nützlich beim Pendeln zwischen zwei Fenstern.
Ctrl-w h # left window
Ctrl-w j # below window
Ctrl-w k # above window
Ctrl-w l # right window
Ctrl-w w # cycle to next window (wraps)
Ctrl-w W # cycle to previous window
Ctrl-w t # top-left window
Ctrl-w b # bottom-right window
Ctrl-w p # previous (last accessed) window
# Faster (with mapping):
:nmap <C-h> <C-w>h
:nmap <C-j> <C-w>j
:nmap <C-k> <C-w>k
:nmap <C-l> <C-w>l
# In terminal mode:
Ctrl-w N # exit terminal mode (to Normal)
Ctrl-w h/j/k/l # navigate (after exiting terminal mode)
# List windows in current tab:
:ls # also shows windows' buffersFenstergröße ändern
Ctrl-w +/-/</> passen die Größe um 1 an; mit einem Zähler präfixen (10 Ctrl-w +) für größere Schritte. Ctrl-w _ maximiert die Höhe, Ctrl-w | die Breite. Ctrl-w = gleicht alle Fenster an. Für Präzision :resize N (Höhe) und :vertical resize N (Breite) nutzen. Mit 'mouse=a' lassen sich Statuszeilen und Trenner direkt ziehen.
Ctrl-w = # equalize all window sizes
Ctrl-w + # increase height by 1
Ctrl-w - # decrease height by 1
Ctrl-w > # increase width by 1
Ctrl-w < # decrease width by 1
Ctrl-w _ # maximize height (current window)
Ctrl-w | # maximize width (current window)
10 Ctrl-w + # increase height by 10
# Ex commands for precise resize:
:resize 20 # set height to 20 (horizontal split)
:resize +5 # increase height by 5
:resize -5 # decrease height by 5
:vertical resize 80 # set width to 80 (vertical split)
:vertical resize +10 # increase width by 10
# Mouse: drag the status line / vertical separator
# (with :set mouse=a)
# Auto-resize on split:
:set equalalways # default: auto-equalize on split/close
:set noequalalways # don't auto-resizeFensterverschiebung
Ctrl-w H/J/K/L bewegen das aktuelle Fenster an die äußeren Kanten (Großbuchstabe = ganze Seite auf dieser Seite). Ctrl-w r/R rotiert Fenster innerhalb des Layouts. Ctrl-w x tauscht mit dem nächsten Fenster. Ctrl-w T bewegt ein Fenster in einen neuen Tab. Ein netter Trick: Ctrl-w K/H konvertiert auch zwischen horizontaler und vertikaler Ausrichtung.
Ctrl-w H # move current window to far LEFT (full height)
Ctrl-w J # move current window to BOTTOM (full width)
Ctrl-w K # move current window to TOP (full width)
Ctrl-w L # move current window to far RIGHT (full height)
Ctrl-w r # rotate windows DOWN/RIGHT
Ctrl-w R # rotate windows UP/LEFT
Ctrl-w x # exchange current window with next
Ctrl-w T # move current window to a NEW tab page
# Move split orientation:
Ctrl-w K # if vertical, become horizontal (and move to top)
Ctrl-w H # if horizontal, become vertical (and move to left)
# Example: convert a vertical split to horizontal:
:vsplit # creates vertical split
Ctrl-w H # moves it to the left, becoming horizontal
# Reopen current buffer in a new tab:
Ctrl-w T # current window moves to a new tabFensteranordnung
Ctrl-w = gleicht Fenstergrößen an. :ball öffnet ein Fenster pro Buffer — nützlich, um alles auf einmal zu sehen. Ctrl-w r/R rotiert Fenster innerhalb des Layouts. Um ein komplettes Fensterlayout zu speichern und wiederherzustellen (inkl. Buffer, Folds usw.), :mksession und :source nutzen. Jede Tabseite pflegt ihr eigenes Fensterlayout.
# Equalize window sizes:
Ctrl-w = # equalize height and width
# Stack layouts:
# Vertical splits side by side, horizontal splits stacked
# Example setup:
# :vsplit -> | win1 | win2 |
# :split -> | win1 | win3 |
# | | win2 |
# Cycle through layouts (with plugins like golden-ratio,
# or use built-in rotation):
Ctrl-w r # rotate down/right
Ctrl-w R # rotate up/left
# Distribute buffers across windows:
:ball # one window per buffer (horizontal)
:vertical ball # one window per buffer (vertical)
# Layouts persist within a tab page.
# Save current layout to a session:
:mksession mylayout.vim
# Restore:
:source mylayout.vim
# Tab page = a collection of windows
:tabnew # new tab with one windowFenster schließen
:q schließt ein Fenster (und verlässt Vim, wenn es das letzte ist). :close (oder Ctrl-w c) schließt ein Fenster, aber nie das allerletzte. :only (Ctrl-w o) schließt alle anderen Fenster. Mit gesetztem 'hidden' verbirgt das Schließen eines Fensters mit geändertem Buffer ihn, statt eine Speicherentscheidung zu erzwingen. :only! erzwingt das Schließen der anderen, selbst wenn geändert.
:q / :quit # close current window (errors if last)
:q! # close without saving
:wq # save and close
:close / Ctrl-w c # close window (won't close last)
:only / Ctrl-w o # close all OTHER windows
:hide # hide current buffer in window (close window)
# Save and close splits:
:xa # save all and exit (close all windows)
:wqa # same as :xa
# Closing a window with modified buffer:
# - :q prompts: "Save changes?"
# - :q! discards
# - :wq saves and closes
# - :hide (with 'hidden' set) keeps buffer in memory
# Close every window except the current:
:only # or Ctrl-w o
# Errors if other windows have unsaved changes:
:only! # force-close other windows
# When you close the last window, Vim exits.
# To prevent accidental exit:
:q! on last window still exits Vim.Tabs
Tabs erzeugen
:tabnew/:tabedit erzeugen eine neue Tabseite. vim -p file1 file2 öffnet jede Datei beim Start in ihrem eigenen Tab. Jede Tabseite enthält ein oder mehrere Fenster — ein Tab ist ein Layout, keine einzelne Datei. Ctrl-w T bewegt das aktuelle Fenster in eine neue Tabseite. Tabs sind super, um unverwandte Arbeitskontexte zu trennen (z. B. ein Tab pro Projektbereich).
:tabnew # new tab with empty buffer
:tabedit file.txt # new tab opening file
:tab split # new tab with current buffer in a split
:tabfind file.txt # new tab, find file in 'path'
# Open multiple files in tabs at startup:
vim -p file1.txt file2.txt file3.txt
# From inside Vim, open files in tabs:
:args *.py | argdo tabe %
# Or one-by-one:
:tabe file1.txt
:tabe file2.txt
# Keyboard shortcut (common mapping):
:nmap <C-t> :tabnew<CR>
# Open current buffer in a new tab (move window):
# Ctrl-w T (move current window to a new tab page)
# Each tab page has its own window layout
# (multiple splits/windows per tab allowed)Tab-Navigation
gt/gT wechseln Tabs (Normalmodus). Ngt springt direkt zu Tab N (1-indiziert). :tabs listet alle Tabseiten und ihre Fenster. Üblich ist das Mappen von Ctrl-Tab/Ctrl-S-Tab oder <leader>1/2/3 für schnellen Tab-Wechsel. Tabs umlaufen standardmäßig. Jeder Tab pflegt sein eigenes Fensterlayout (Splits usw.).
:tabnext / :tabn # next tab
:tabprevious / :tabp # previous tab
:tabfirst / :tabr # first tab
:tablast / :tabl # last tab
gt # next tab (Normal mode)
gT # previous tab
3gt # go to tab 3
:tabn 3 # go to tab 3 (Ex command)
# Common mappings (Vim default):
:nmap <C-Tab> :tabnext<CR>
:nmap <C-S-Tab> :tabprevious<CR>
# Or use leader keys:
:nmap <leader>1 1gt
:nmap <leader>2 2gt
:nmap <leader>3 3gt
# Cycle behavior:
# gt at last tab wraps to first
# gT at first tab wraps to last
# To disable wrap:
:set tabpagemax=50 # max tabs (not wrap-related)
# Show all tabs:
:tabs # list tabs with their windowsTab-Operationen
:tabc schließt den aktuellen Tab; :tabo alle anderen. :tabm N verschiebt den aktuellen Tab auf Position N (0 = erster). :tabdo führt einen Ex-Befehl in jedem Tab aus — nützlich für globale Operationen über tab-getrennte Arbeitsbereiche hinweg. Das Schließen eines Tabs schließt alle seine Fenster; geänderte Buffer bleiben erhalten, wenn 'hidden' gesetzt ist.
:tabclose / :tabc # close current tab
:tabclose! / :tabc! # force close (discard changes)
:tabonly / :tabo # close all OTHER tabs
:tabonly! / :tabo! # force close others
# Reorder tabs:
:tabmove / :tabm 0 # move current tab to position 0 (first)
:tabm # move to last position
:tabm 2 # move to position 2
:tabm +1 # move right by 1
:tabm -1 # move left by 1
# Quick keyboard reordering (no default, common mapping):
:nmap <leader>tm :tabmove<Space>
# Run a command in every tab:
:tabdo cmd # run cmd in every tab page
# Example:
:tabdo %s/old/new/ge # substitute in every tab's first window
# Each tab can hold multiple windows/splits.
# 'Tabclose' closes all windows in the tab.Tab-Layout & Mehrfenster
Jede Tabseite pflegt ein unabhängiges Fensterlayout (Splits, Größen, Positionen). Mehrere Fenster pro Tab sind möglich. Ctrl-w T bewegt ein Fenster in seinen eigenen neuen Tab. :set showtabline=2 zeigt die Tab-Leiste immer. Tabs eignen sich am besten als Arbeitsbereich-Trenner (z. B. ein Tab pro Projektbereich), jeder mit eigenem Layout.
# Each tab page has its own window layout.
# Create a tab with a 3-window layout:
:tabnew # new tab
:vsplit # split vertically (2 windows)
:split # split horizontally (3 windows)
# Now tab has: [win1] [win2]
# [win3]
# Add a buffer to current tab:
:e file.txt # replaces current window's buffer
# Move a window to its own tab:
Ctrl-w T # window becomes a new tab page
# Show tab line (always):
:set showtabline=2 # 0=never, 1=multi-tab, 2=always
# Tab page-local options:
:setlocal ... # option applies only to current tab's windows
:tabdo setlocal ... # apply across all tabs
# Tab label customization (status line):
:set guitablabel=%t # show filename in GUI tab label
# Common use case: one tab per project area:
# Tab 1: source files
# Tab 2: tests
# Tab 3: docs
# Each with its own split layout.Tab-Optionen & Labels
showtabline steuert die Tab-Leiste (0=nie, 1=nur bei mehreren Tabs, 2=immer). Die Tab-Leiste lässt sich mit einer Funktion, die den Formatstring liefert, vollständig anpassen — nützlich, um Änderungsstatus, Buffer-Namen, Tab-Nummern zu zeigen. guitablabel/guitabtooltip passen GUI-Vim an. Tabs werden ab 1 nummeriert.
:set showtabline=2 # always show tab bar (0=never, 1=auto)
:set tabpagemax=50 # max tabs creatable
:set hidden # allow switching tabs with unsaved changes
# Custom tab labels (terminal Vim):
:set tabline=%!MyTabLine()
function! MyTabLine()
let s = ''
for i in range(tabpagenr('$'))
let n = i + 1
let s .= '%' . n . 'T'
let s .= (n == tabpagenr() ? '%#TabLineSel#' : '%#TabLine#')
let s .= ' [' . n . '] '
let buflist = tabpagebuflist(n)
let bufname = bufname(buflist[0])
let s .= empty(bufname) ? '[No Name]' : fnamemodify(bufname, ':t')
let s .= ' '
endfor
let s .= '%T%#TabLineFill#'
return s
endfunction
# GUI tab labels:
:set guitablabel=%t # show filename
:set guitabtooltip=%f # show full path on hover
# Quickly switch with number:
:nmap <leader>t :tabs<CR>Tabseiten-Befehle
:tabs listet Tabs und ihre Fenster. :tabdo führt einen Ex-Befehl in jedem Tab aus. :tab ball öffnet jeden Buffer in seinem eigenen Tab. <C-w>gf öffnet die Datei unter dem Cursor in einem neuen Tab. Tabs nutzen, um verwandte Dateien zu gruppieren (ein Tab pro Feature/Bereich). Für tab-übergreifende Operationen ist :tabdo das Arbeitstier — mit windo paaren für Mehrfenster-Tabs.
:tabs # list all tabs and their windows
:tabdo cmd # run cmd in every tab
:tab ball # open each buffer in its own tab
:tab help subject # open help in a new tab
:tab split # split current window into new tab
# Quickly duplicate a tab's layout:
# (no built-in, but possible with sessions)
# Or manually: create a new tab, re-open buffers
# Open file under cursor in a new tab:
:nmap gf :tabe <cfile><CR>
# (or use the built-in <C-w>gf)
# Common workflow:
# 1. Group related files in tabs
# 2. Use gt/gT to switch
# 3. Use :tabdo for cross-tab operations
# Save all tabs' buffers:
:tabdo windo w # write every window in every tab
# (or simpler)
:wall # write all buffers (across all tabs)
# Close all tabs but keep buffers:
# (no single command — use :tabo + :b then :bd)Konfiguration (.vimrc)
vimrc-Grundlagen
$MYVIMRC ist der Pfad zu deiner vimrc-Datei — :edit $MYVIMRC öffnet sie, :source $MYVIMRC lädt nach Änderungen neu. Der runtimepath steuert, wo Vim nach Syntaxdateien, Plugins usw. sucht. :verbose set option? nutzen, um zu sehen, wo eine Option zuletzt gesetzt wurde — unbezahlbar zum Debuggen konfligierender Plugins.
# vimrc location:
# Unix: ~/.vimrc (or ~/.vim/vimrc)
# Windows: ~/_vimrc (or ~/vimfiles/vimrc)
# Neovim: ~/.config/nvim/init.vim
# Reload vimrc after editing:
:source $MYVIMRC # or :so %
# Edit vimrc quickly:
:edit $MYVIMRC # $MYVIMRC = path to your vimrc
# Runtime path (where Vim looks for scripts):
:set runtimepath?
# Add a custom path:
:set runtimepath+=~/.vim/custom
# Conditional config (only in terminal Vim):
if !has('gui_running')
set mouse=a
endif
# Per-filetype settings (in vimrc or ftplugin/):
:autocmd FileType python setlocal expandtab shiftwidth=4
# Check where an option was set:
:verbose set tabstop?Grundeinstellungen
Dies sind übliche Komfort-Einstellungen. relativenumber + number zeigt hybride Nummerierung — Zeilennummern relativ zum Cursor für einfache Sprünge, mit absoluter auf der aktuellen Zeile. showmatch blitzt passende Klammern auf. wildmenu verbessert die :command-Vervollständigung mit einem Menü. scrolloff hält Kontext um den Cursor sichtbar — nie am Bildschirmrand bearbeiten.
set nocompatible # Vim mode (not Vi)
set number # show line numbers
set relativenumber # relative line numbers (great for jumps)
set cursorline # highlight current line
set cursorcolumn # highlight current column
set showcmd # show partial commands in status
set showmode # show current mode (insert, visual...)
set showmatch # highlight matching brackets
set wildmenu # better command-line completion
set wildmode=longest:full,full # completion style
set laststatus=2 # always show status line
set ruler # show cursor position
set backspace=indent,eol,start # backspace through everything
set encoding=utf-8 # default encoding
set scrolloff=5 # keep 5 lines above/below cursor
set sidescrolloff=5 # keep 5 cols left/right of cursor
set mouse=a # enable mouse (all modes)Einrückung
tabstop steuert, wie viele Spalten ein Tab-Zeichen darstellt. shiftwidth ist der Einrückungsbetrag, genutzt von <<, >> und autoindent. softtabstop lässt Backspace die richtige Spaltenzahl entfernen, selbst wenn expandtab aus ist. expandtab konvertiert Tabs zu Leerzeichen — für Konsistenz empfohlen. :retab konvertiert bestehende Tabs/Leerzeichen nach dem Ändern der Einstellungen.
set autoindent # copy indent from previous line
set smartindent # smart auto-indent for code (basic)
set cindent # C-style indenting (more language-aware)
set expandtab # use spaces instead of tabs
set tabstop=4 # tab key inserts 4-column tabs visually
set shiftwidth=4 # indent/outdent amount (<<, >>, autoindent)
set softtabstop=4 # backspace removes 4 cols even with tabs
set shiftround # round indent to multiple of shiftwidth
set smarttab # tab key respects shiftwidth at line start
# Toggle tabs vs spaces:
:set expandtab! # toggle
:retab # convert existing tabs<->spaces
# Filetype-specific indent:
:filetype plugin indent on
# Then in ~/.vim/ftplugin/python.vim:
# setlocal expandtab shiftwidth=4
# Quick indent/dedent in Normal mode:
>> # indent current line
<< # dedent current line
5>> # indent 5 linesSucheinstellungen
ignorecase + smartcase ist die empfohlene Kombination: schreibunabhängig, außer dein Muster hat einen Großbuchstaben. hlsearch hebt alle Treffer hervor; incsearch zeigt Treffer inkrementell beim Tippen. Übliches Mapping: <leader>h schaltet hlsearch um, oder :noh löscht die aktuelle Hervorhebung. Vim 8.2+ kann die Suchanzahl via shortmess zeigen.
set ignorecase # case-insensitive search
set smartcase # case-sensitive if pattern has uppercase
set hlsearch # highlight all matches (hls)
set incsearch # show match as you type (is)
set wrapscan # wrap search around end of file (ws)
# Toggle search highlight:
:nmap <leader>h :set hlsearch!<CR>
# Or clear current highlight:
:nmap <leader>nh :nohlsearch<CR>
# Show search count (Vim 8.2+):
:set shortmess-=S
:set shortmess+=S # search stats in command line
# Search in visual selection:
:vmap * y/\V<C-R>"<CR>
# Use very-magic mode by default (advanced):
# No built-in, but a search mapping can prepend \v
# Improved '*' (don't jump on first press):
:nmap * *N
# Disable highlighting until next search:
:nohlsearchAnzeigeeinstellungen
wrap + linebreak brechen lange Zeilen an Wortgrenzen um (nicht mitten im Wort) für Lesbarkeit. list + listchars legen Tabs, nachgestellten Whitespace und geschützte Leerzeichen offen. colorcolumn markiert eine Spalte (z. B. 80 für Zeilenlängenlimits). termguicolors aktiviert echtes 24-Bit-Farb in modernen Terminals. splitright/splitbelow steuern, wo neue Splits erscheinen.
set wrap # wrap long lines
set linebreak # wrap at word boundaries (not mid-word)
set textwidth=80 # auto-wrap at 80 chars when typing
set showbreak=+++ # marker for wrapped lines
set list # show invisible chars
set listchars=tab:>-,trail:.,extends:>,precedes:<
set fillchars=fold:-,vert:\| # chars for folds/vsplits
set colorcolumn=80 # highlight column 80
set signcolumn=yes # always show sign column (LSP)
set conceallevel=0 # don't conceal chars
set splitright # new vsplit on the right
set splitbelow # new split below
set termguicolors # 24-bit color (if terminal supports)
set background=dark # or 'light' — adjusts color scheme
# Color scheme:
:colorscheme desert
# Or with a plugin (e.g. vim-colors-solarized):
:colorscheme solarizedTasten mappen
Für eigene Mappings IMMER die *noremap-Varianten nutzen (nnoremap, vnoremap usw.) — sie rekursieren nicht und vermeiden unerwartetes Verhalten. <leader> ist ein anpassbarer Präfix-Schlüssel (Standard Backslash; viele setzen ihn auf Komma oder Leerzeichen). <CR> ist Enter, <Esc> ist Escape, <C-x> ist Ctrl-X. Leader-Shortcuts für häufige Befehle wie Speichern/Beenden mappen.
# Map families:
:map # normal, visual, select, operator-pending
:nmap # normal mode only
:imap # insert mode only
:vmap # visual + select mode
:xmap # visual mode only
:smap # select mode only
:omap # operator-pending mode only
:cmap # command-line mode only
:tmap # terminal mode only
# Non-recursive (RECOMMENDED):
:nnoremap # normal mode, non-recursive
:vnoremap # visual mode, non-recursive
:inoremap # insert mode, non-recursive
:cnoremap # command-line mode, non-recursive
# Examples:
nnoremap <leader>w :w<CR> # save with leader-w
nnoremap <leader>q :q<CR> # quit
inoremap jk <Esc> # Esc with jk
nnoremap <C-h> <C-w>h # window nav
# Leader key (default is \):
:let mapleader = ','
:let maplocalleader = '\\'
# Special keys:
# <CR> <Esc> <Tab> <Space> <C-x> <A-x> <M-x> <F1>-<F12>
# <Up> <Down> <Left> <Right> <leader> <localleader>Plugins (vim-plug)
vim-plug-Grundlagen
vim-plug ist der beliebteste moderne Plugin-Manager. Plugins zwischen call plug#begin und plug#end deklarieren. Jede Plug-Zeile spezifiziert ein GitHub-Repo (user/repo). Nach dem Ergänzen von Plugins :source $MYVIMRC, dann :PlugInstall zum Herunterladen. Auf einen Tag, Branch oder Commit pinnen für Stabilität. Plugins installieren ins 'plugged'-Verzeichnis.
# Installation (Unix):
# curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
# https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
# In vimrc:
call plug#begin('~/.vim/plugged')
Plug 'junegunn/fzf.vim' " GitHub repo: user/repo
Plug 'tpope/vim-surround' " another plugin
Plug 'morhetz/gruvbox' " colorscheme
Plug 'preservim/nerdtree' " file explorer
call plug#end()
# After editing vimrc:
:source $MYVIMRC # or restart Vim
:PlugInstall # install all declared plugins
# Plugin directory structure:
# ~/.vim/plugged/<plugin-name>/
# Pin to a specific commit/tag/branch:
Plug 'tpope/vim-fugitive', { 'tag': 'v3.0' }
Plug 'user/repo', { 'branch': 'dev' }
Plug 'user/repo', { 'commit': 'abc123' }Plugin-Verwaltungsbefehle
:PlugInstall installiert neue Plugins, :PlugUpdate aktualisiert alle, :PlugClean entfernt ungelistete, :PlugStatus zeigt ihren Zustand. Der 'do'-Hook führt nach der Installation einen Befehl aus — nützlich für Plugins, die bauen oder Binärdateien installieren müssen. Die Optionen 'on'/'for' aktivieren Lazy Loading (laden nur, wenn ein Befehl/Filetype sie auslöst) — verbessert die Startzeit.
:PlugInstall # install newly added plugins
:PlugUpdate # update all plugins
:PlugClean # remove plugins no longer in vimrc
:PlugStatus # show plugin status (loaded, errored)
:PlugUpgrade # update vim-plug itself
:PlugDiff # review changes from last update
:PlugSnapshot # generate a snapshot of plugin versions
# Post-install hooks:
Plug 'user/repo', { 'do': ':GoInstallBinaries' }
Plug 'user/repo', { 'do': './install.sh' }
Plug 'user/repo', { 'do': 'npm install' }
# Lazy loading (load only when needed):
Plug 'user/repo', { 'on': 'CommandName' } " on command
Plug 'user/repo', { 'for': 'python' } " for filetype
Plug 'user/repo', { 'on': ['Cmd1', 'Cmd2'] }
# Frozen plugin (don't update):
Plug 'user/repo', { 'frozen': 1 }
# Disable a plugin temporarily:
# (no built-in, but comment out the Plug line and :PlugClean)Häufige essenzielle Plugins
Übliche Essentials: fzf für fuzzy Suche von Dateien/Buffer/Text (viel schneller als :find), vim-surround zum Bearbeiten von Anführungszeichen/Klammern/Tags um Text, vim-fugitive für Git-Integration, vim-commentary für schnelles Kommentieren (gc-Operator), NERDTree für eine Datei-Explorer-Seitenleiste, vim-airline für eine hübschere Statuszeile und ein gutes Farbschema wie gruvbox.
" Fuzzy finder (requires fzf binary):
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
" :Files :GFiles :Buffers :Rg
" Surround (cs/ds/ys for surroundings):
Plug 'tpope/vim-surround'
" cs"' change " to '
" ds" delete surrounding "
" ysiw) surround word with ()
" Fugitive (Git integration):
Plug 'tpope/vim-fugitive'
" :G :Gstatus :Gcommit :Gpush
" Commentary (gc to toggle comments):
Plug 'tpope/vim-commentary'
" gcc comment line
" gc{motion} comment motion
" NERDTree (file explorer sidebar):
Plug 'preservim/nerdtree'
" :NERDTree :NERDTreeToggle
" Airline (status line):
Plug 'vim-airline/vim-airline'
" Gruvbox (colorscheme):
Plug 'morhetz/gruvbox'Plugin-Konfiguration
'on'/'for' nutzen, um Plugins lazy zu laden — sie laden nur bei Auslösung und verbessern die Startzeit. Pluginspezifische Konfiguration nutzt typisch g:pluginname_var-Variablen in der vimrc ODER Dateien in ~/.vim/after/plugin/. Der 'do'-Hook läuft nach Installation/Update für Build-Schritte. g:loaded_pluginname=1 in der vimrc zu setzen verhindert, dass ein Plugin überhaupt lädt.
" Lazy load on command:
Plug 'tpope/vim-fugitive', { 'on': 'Git' }
" Lazy load on filetype:
Plug 'fatih/vim-go', { 'for': 'go' }
" Multiple triggers:
Plug 'junegunn/fzf.vim', { 'on': ['Files', 'Buffers', 'Rg'] }
" Post-install hook:
Plug 'dense-analysis/ale', { 'do': 'npm install' }
" Configuration AFTER plugin loads:
Plug 'preservim/nerdtree'
let g:NERDTreeShowHidden = 1
let g:NERDTreeWinSize = 30
nmap <leader>n :NERDTreeToggle<CR>
" Configuration in AFTER/plugin-name.vim:
" (alternative to setting g: vars in vimrc)
" ~/.vim/after/plugin/nerdtree.vim:
" let g:NERDTreeShowHidden = 1
" Disable plugin entirely:
let g:loaded_nerdtree = 1 " prevent loadingPlugin-Laden & Laufzeit
Vim sourced plugin/*.vim-Dateien beim Start in Verzeichnisreihenfolge, dann after/plugin/*.vim zuletzt (für Overrides). :scriptnames listet alles Gescourcte — unbezahlbar zum Debuggen. :verbose map <key> zeigt, wo ein Mapping definiert wurde; :verbose set option? macht dasselbe für Optionen. autoload/-Dateien laden lazy, wenn ihre Funktionen erstmals aufgerufen werden.
" Plugin loading sequence:
" 1. Vim starts, reads vimrc
" 2. plug#begin / plug#end registers plugins
" 3. Runtime path is updated to include plugin dirs
" 4. plugin/*.vim files are sourced (in directory order)
" 5. after/plugin/*.vim files are sourced last
" Check if a plugin is loaded:
:echo exists('g:loaded_fugitive')
:scriptnames # list all sourced scripts in order
" Manually source a plugin:
:source ~/.vim/plugged/foo/plugin/foo.vim
" Find where a mapping was defined:
:verbose map <leader>w
" Find where an option was set:
:verbose set formatprg?
" Plugin runtime files:
" plugin/ - loaded at startup
" ftplugin/ - loaded for specific filetypes
" syntax/ - syntax highlighting
" indent/ - indentation rules
" autoload/ - lazily-loaded functions
" after/ - sourced last (overrides)
" Helptags for plugin docs:
:Helptags (vim-plug generates these on install)Alternative Plugin-Manager
Jenseits von vim-plug gibt es Vundle (ähnliche API, weniger funktionsreich), Pathogen (am einfachsten — ergänzt nur bundle-Verzeichnisse zum runtimepath), Dein.vim (schnell, Lazy-Loading-fokussiert) und Vim 8+'s eingebaute Packages (kein Plugin-Manager nötig — Plugins in pack/<name>/start/ ablegen). Für Neovim-Nutzer ist Packer (Lua-basiert) beliebt. Eingebaute Packages sind super für Minimalisten.
" 1. Vundle (older, similar to vim-plug):
" set rtp+=~/.vim/bundle/Vundle.vim
" call vundle#begin()
" Plugin 'tpope/vim-surround'
" call vundle#end()
" 2. Pathogen (just adds dirs to runtimepath):
" Execute:
" git clone https://github.com/tpope/vim-pathogen ~/.vim/bundle
" In vimrc:
" execute pathogen#infect()
" Then clone plugins into ~/.vim/bundle/
" 3. Dein.vim (modern, lazy-loading focused):
" set runtimepath+=~/.cache/dein/repos/github.com/Shougo/dein.vim
" if dein#load_state('~/.cache/dein')
" call dein#begin('~/.cache/dein')
" call dein#add('tpope/vim-surround')
" call dein#end()
" call dein#save_state()
" endif
" 4. Vim 8+ built-in packages (NO plugin manager needed):
" Place plugins in:
" ~/.vim/pack/<name>/start/<plugin>/ " loaded at startup
" ~/.vim/pack/<name>/opt/<plugin>/ " loaded on demand
" Load an opt plugin: :packadd <plugin>
" 5. Packer (Neovim Lua):
" require('packer').startup(function()
" use 'tpope/vim-surround'
" end)Fortgeschrittene Bewegung
Zeichensuche (f/F/t/T)
f/F findet das nächste/vorherige Zeichen auf der aktuellen Zeile (der Cursor landet darauf); t/T bewegen bis kurz davor/danach. ; wiederholt das letzte f/F/t/T in dieselbe Richtung, , in die entgegengesetzte. Mit Operatoren kombinieren: dt, löscht bis (nicht einschließlich) zum nächsten Komma, df. durch den nächsten Punkt hindurch. Schnell und präzise für In-Line-Navigation.
f{x} # find next char 'x' on line (cursor ON x)
F{x} # find previous char 'x' (cursor ON x)
t{x} # till next char 'x' (cursor BEFORE x)
T{x} # till previous char 'x' (cursor AFTER x)
; # repeat last f/F/t/T (same direction)
, # repeat last f/F/t/T (opposite direction)
# Examples (cursor on 'a' in "hello world abc"):
# fw -> cursor on 'w' (world)
# tw -> cursor on space before 'w'
# Fo -> cursor on 'o' (hello) - backwards
# ; -> next 'w'... or next match of last
# Combined with operators:
dt, # delete up to (not including) next ','
df. # delete up to AND including next '.'
ct; # change up to next ';'
yt: # yank up to next ':'
# Find on a long line (no built-in multi-line f):
# Use :s or search for multi-line patterns.
# Set 'hlsearch' to highlight f/F/t/T targets:
:set hlsearch " doesn't highlight f, but / does.Satz- & Absatzbewegung
( und ) bewegen sich nach Satz (Sätze enden mit . ! ? plus Whitespace); { und } nach Absatz (durch Leerzeilen getrennt). Bei umbrochenen Zeilen arbeiten gj/gk/g0/g$ auf sichtbaren Bildschirmzeilen, während j/k/0/$ auf logischen Zeilen arbeiten — essenziell, wenn 'wrap' an ist. ( ) { } mit Operatoren kombinieren: das löscht einen Satz, yap yankt einen Absatz.
( # previous sentence start
) # next sentence start
{ # previous paragraph start (blank-line delimited)
} # next paragraph start
# Sentence boundaries: ends with . ! ? followed by
# whitespace or end of paragraph.
# Paragraph: block of lines separated by blank lines.
# Examples:
# Hello world. This is a sentence.
# ^ ^ ^
# ( ) ( moves to sentence starts
# Combine with operators:
das # delete a sentence
cis # change inside sentence
yap # yank a paragraph
dip # delete inside paragraph
# Move by visual line (with 'wrap' on):
gj # down one screen line (wrap-aware)
gk # up one screen line
g0 # start of screen line
g$ # end of screen line
g_ # last non-blank of screen line
# These respect wrapping where j/k don't.Paare matchen (%)
% springt zwischen passenden Klammern (Default: (), [], {}). Er arbeitet auch auf #if/#endif und /* */, wenn 'matchpairs' passend gesetzt ist. Mit Operatoren kombinieren: d% löscht vom Cursor bis zum Match, v% wählt ihn. [( [{ ]) ]} springen zu ungepaarten Klammern — nützlich, um den umschließenden Funktions-/Klassenblock zu finden.
% # jump to matching bracket: ( ) [ ] { }
# also works on #if/#endif, /* */ with matching pairs
# In Normal mode:
% # if cursor on (, jumps to matching )
% # if cursor on ), jumps to matching (
# Combine with operators:
d% # delete from cursor to matching bracket
c% # change from cursor to matching bracket
y% # yank from cursor to matching bracket
v% # visually select from cursor to matching bracket
# Extend matching to other pairs:
:set matchpairs+=<:>
:set matchpairs+=«:»
# Default: (:),[:],{:}
# Move to enclosing bracket:
# [( # back to unmatched (
# ]) # forward to unmatched )
# [{ # back to unmatched {
# ]} # forward to unmatched }
# [} / ]{ similar for braces
# Example: jump to outer function's opening brace:
[{ " previous unmatched {Bildschirmbewegung
H/M/L springen an oben/Mitte/unten des sichtbaren Bildschirms. Ctrl-f/b scrollt ganze Seiten; Ctrl-d/u halbe (weniger desorientierend); Ctrl-e/y scrollt eine Zeile, ohne den Cursor zu bewegen. zz/zt/zb positioniert die Cursorzeile zur Mitte/oben/unten des Bildschirms neu — essenziell, um Kontext zu halten. 'scrolloff' stellt sicher, dass der Cursor nie den Bildschirmrand erreicht.
H # top of screen (High) — first non-blank
M # middle of screen
L # bottom of screen (Low) — first non-blank
N H # Nth line from top (e.g. 5H = 5 lines from top)
N L # Nth line from bottom
# Scrolling:
Ctrl-f # forward (down) full screen
Ctrl-b # backward (up) full screen
Ctrl-d # down half screen
Ctrl-u # up half screen
Ctrl-e # scroll down 1 line (cursor stays)
Ctrl-y # scroll up 1 line (cursor stays)
# Reposition cursor on screen:
zz # cursor line to middle of screen
zt # cursor line to top of screen
zb # cursor line to bottom of screen
z. # cursor to middle, first non-blank
z+ # cursor to bottom, scroll up (like zb but accepts count)
# Keep cursor off edges:
:set scrolloff=5 # always 5 lines above/below cursor
:set sidescrolloff=5 # 5 cols left/right of cursorScroll-Bindung & Sync
:set scrollbind synchronisiert das Scrollen über Fenster hinweg — in jedem zu synchronisierenden Fenster setzen. :vimdiff öffnet zwei Dateien im Diff-Modus mit scrollbind, syntaxhervorgehobenen Unterschieden und [c/]c zum Navigieren von Hunks. do (diff obtain) zieht Änderungen vom anderen Fenster, dp (diff put) schiebt sie hin. Super, um Versionen einer Datei zu vergleichen.
# Bind windows to scroll together:
:set scrollbind # current window syncs scroll
:set syncbind # force immediate sync
:scrollbind # same as :set scrollbind
# In each window you want synced:
# :set scrollbind
# Unbind:
:set noscrollbind
# Common use: diff two files side by side
:vimdiff file1 file2 # opens both, scrollbound, diff highlighted
:diffthis # mark current window as a diff
:diffoff # turn off diff mode for current window
:diffupdate # refresh diff highlighting
# Vertical diff split:
:vert diffsplit file2.txt
# In diff mode:
[c # previous diff hunk
]c # next diff hunk
do # diff obtain (pull from other window)
dp # diff put (push to other window)
# Bind but at different starting positions:
# Set scrollbind AFTER scrolling to desired positions.Zu Positionen gehen
Viele Wege, den Cursor zu positionieren: :N für Zeile N, N% für Prozentsatz, `.`/`"/[`]/`</`> für besondere Marks (letzte Änderung, letztes Ende, letzter Yank, letzte visuelle Auswahl). Ctrl-o/Ctrl-i navigieren die Jumplist. `" stellt die Position beim letzten Schließen der Datei wieder her — kombiniert mit einer viminfo-Einstellung hält das über Sessions hinweg.
:N # go to line N (e.g. :42)
Ng / N G # go to line N (e.g. 42G or 42gg)
gg # first line
G # last line
N% # go to N% of file (e.g. 50% = middle)
:-N # N lines before current (e.g. :-5)
:+N # N lines after current (e.g. :+10)
# Marks and jumps:
\`. # position of last change in this buffer
\`" # position when file was last closed
\`[ # start of last yanked/changed region
\`] # end of last yanked/changed region
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # last insert position (gi goes here + insert)
# Recent jumps:
Ctrl-o # back in jumplist
Ctrl-i # forward in jumplist
\`' # position before last jump (where you came from)
# File position on save:
:set viminfo^=% # remember buffer positions across sessions
# Cursor hold (no movement for 'updatetime' ms):
# CursorHold event triggers (advanced)Befehlszeilen-Modus
Bereichsbefehle
Bereiche geben an, welche Zeilen ein Befehl betrifft. :% ist die ganze Datei (1,$). . ist die aktuelle Zeile, $ die letzte. '<,'> ist die letzte visuelle Auswahl (automatisch gefüllt, wenn du : im Visual-Modus drückst). 'a,'b ist von Mark a bis Mark b. Auch Suchmuster als Bereichsgrenzen nutzbar: :/foo/,/bar/d löscht von der foo-treffenden bis zur bar-treffenden Zeile.
# Range syntax: :{start},{end}command
# Range forms:
:% # whole file (1,$)
:1,10 # lines 1-10
:.,$ # current line to end of file
:1,. # first line to current
:'a,'b # from mark a to mark b
:'<,'> # last visual selection
:. # current line only
:N # line N only
:.,+5 # current line + 5 below
:.,-2 # current line - 2 above
# Examples:
:1,10d # delete lines 1-10
:%s/old/new/g # substitute whole file
:'<,'>s/old/new/g # substitute visual selection
:.,$j # join from current to end into one line
:5,10y a # yank lines 5-10 into register a
:g/pattern/m$ # move matching lines to end of file
# Search-based range:
:/start/,/end/d # delete from 'start' to 'end' patternsDateibefehle
:w speichert, :e öffnet eine neue Datei, :r fügt den Inhalt einer anderen Datei ein (oder Shell-Befehlsausgabe via :r !cmd). :saveas speichert und wechselt zur neuen Datei. :e! lädt die Datei neu und verwirft Änderungen. ++enc/++ff geben Encoding/Zeilenenden explizit an — nützlich zum Konvertieren von Dateien. :browse e öffnet einen GUI-Dateidialog (in GUI-Vim).
:w / :write # save current file
:w file.txt # save as new file
:w! file.txt # overwrite existing file
:w >> file.txt # append to file
:saveas / :sav file # save as new file and switch to it
:e / :edit file # open file (replace current buffer)
:e! # reload current file (discard changes)
:e # # edit alternate file
:r / :read file # insert file below cursor
:r !command # insert command output below cursor
:0r !date # insert date at top of file
# Multiple files:
:wa / :wall # write all buffers
:xa / :xall # write all and quit
:qa! # quit all without saving
# Browse file system:
:browse e # GUI file open dialog
:Explore # Netrw file browser
# File encoding:
:w ++enc=utf-8 # save as UTF-8
:e ++enc=latin1 file # open with specific encoding
# File format (line endings):
:w ++ff=unix # save as Unix line endingsBuffer- & Fensterbefehle
Alle Multi-Buffer-/Fenster-/Tab-Operationen haben Ex-Befehlsformen. :b wechselt Buffer, :sp/:vs teilen Fenster, :tabnew erzeugt Tabs. Die :*do-Familie (bufdo, argdo, tabdo, windo, cdo) führt einen Befehl über viele Ziele aus — extrem mächtig für Batch-Operationen. :ls zeigt Buffer; :tabs zeigt Tabs; :args zeigt die Arglist.
# Buffer commands:
:b N / :buffer N # switch to buffer N
:b name # switch by name (tab-completes)
:bd / :bdelete # delete buffer
:bw / :bwipeout # wipe buffer (clears marks)
:ls / :buffers # list buffers
:bn / :bp # next / previous buffer
:b# # alternate buffer
# Window commands:
:sp / :split # horizontal split
:vs / :vsplit # vertical split
:new # split with empty buffer
:close # close window
:only # close all other windows
:qa / :qa! # quit all windows
# Tab page commands:
:tabnew # new tab
:tabe file # new tab with file
:tabc # close tab
:tabo # close other tabs
:tabs # list tabs
:tabn / :tabp # next / previous tab
# Argument list commands:
:args # show arg list
:n / :next # next arg file
:prev # previous arg file
:argdo cmd # run cmd on each arg fileOptionen setzen
:set schaltet boolesche Optionen mit ! um, setzt Werte mit =, hängt an/entfernt mit +=/-= und setzt auf Defaults zurück mit &. :set option? zeigt den aktuellen Wert. :setlocal setzt einen buffer-/fensterlokalen Wert (berührt andere Buffer nicht). :set ohne Argumente listet alle geänderten Optionen; :set all zeigt alles. Tab vervollständigt Optionsnamen.
:set option # turn boolean option on
:set nooption # turn boolean option off
:set option! # toggle boolean
:set option? # show current value
:set option=value # set value
:set option+=value # append to value
:set option-=value # remove from value
:set option& # reset to default
:set all # show all options
:set # show changed options
# Local vs global:
:setlocal option # buffer/window-local only
:setglobal option # global value
# Examples:
:set number # show line numbers
:set nonumber # hide line numbers
:set number! # toggle
:set tabstop=4 # set tabstop to 4
:set formatoptions+=r # add 'r' to formatoptions
:set ignorecase& # reset ignorecase to default
# View all set options:
:set # shows only non-default values
# Find option with substring:
:set ic<tab> # tab-complete (ignorecase)Map-Befehle
Die *noremap-Varianten für eigene Mappings nutzen — sie rekursieren nicht und verhindern unerwartetes Verhalten. <leader> ist ein anpassbarer Präfix (Standard Backslash; viele setzen ihn auf Leerzeichen oder Komma). <buffer> macht ein Mapping lokal zum aktuellen Buffer. Besondere Tasten nutzen <notation> wie <CR>, <Esc>, <C-x> (Ctrl-X), <A-x> (Alt-X).
:map <key> <action> # generic map (most modes)
:nmap <key> <action> # normal mode
:imap <key> <action> # insert mode
:vmap <key> <action> # visual mode
:xmap <key> <action> # visual mode only
:smap <key> <action> # select mode
:omap <key> <action> # operator-pending mode
:cmap <key> <action> # command-line mode
:tmap <key> <action> # terminal mode
# Non-recursive (RECOMMENDED for personal mappings):
:nnoremap <key> <action> # normal mode
:vnoremap <key> <action> # visual mode
:inoremap <key> <action> # insert mode
:onoremap <key> <action> # operator-pending
:cnoremap <key> <action> # command-line
:tnoremap <key> <action> # terminal
# Buffer-local mappings:
:nnoremap <buffer> <key> <action>
# Clear a mapping:
:nunmap <key> # or :nmapclear (clears all normal maps)
# Special keys in mappings:
# <CR> <Esc> <Tab> <Space> <BS> <C-x> <A-x> <M-x>
# <F1>-<F12> <Up> <Down> <Left> <Right>
# <leader> <localleader> <C-r> <C-w>
:let mapleader = ' '
:let maplocalleader = '\\'Nützliche Ex-Befehle
:!cmd führt einen Shell-Befehl aus; :r !cmd fügt seine Ausgabe in den Buffer ein. :sort sortiert Zeilen (u=eindeutig, n=numerisch, !=umgekehrt). :retab konvertiert zwischen Tabs und Leerzeichen. :normal führt Normalmodus-Tastenschläge als Ex aus — ! ergänzen, um eigene Mappings zu ignorieren. :%!cmd pipet die ganze Datei durch einen externen Befehl und ersetzt sie durch die Ausgabe.
:!command # run shell command
:r !command # insert command output below cursor
:!! # repeat last :! command
:sh # open a shell (exit to return)
:terminal / :term # open terminal in a window
:read file # insert file contents below cursor
:sort # sort selected lines (visual mode)
:sort u # sort and remove duplicates
:sort n # numeric sort
:sort! # reverse sort
:retab # convert tabs to spaces (and vice versa)
:retab! # also convert in strings
:normal {cmds} # run normal-mode commands
:normal! {cmds} # ignore mappings (use raw keys)
# Execute Ex commands from a register:
:@a # run Ex commands in register 'a'
:@@ # repeat last :@
# Range + command examples:
:5,20s/old/new/g # substitute in lines 5-20
:%!sort # pipe whole file through sort
:'<,'>!column -t # format visual selection as columns
# Help:
:help :command # help on a specific commandVimscript-Grundlagen
Variablen
Vimscript nutzt let für Zuweisung und unlet zum Löschen. Variablen haben Scopes, angezeigt durch Präfixe: g: (global), b: (buffer), w: (window), t: (tab), s: (script), l: (funktionslokal), v: (eingebaut). const erzeugt unveränderliche Werte (Vim 8+). exists() prüft, ob eine Variable definiert ist. Vim 8.2+ unterstützt String-Interpolation mit $"...{expr}...".
let var = value # assignment
let var = "hello" # string
let var = 42 # number
let var = 3.14 # float
let var = [1, 2, 3] # list
let var = {"key": "val"} # dictionary
unlet var # delete a variable
# Variable scopes (prefix with letter + colon):
let g:global_var = 1 # global (everywhere)
let b:buffer_var = 1 # buffer-local
let w:window_var = 1 # window-local
let t:tab_var = 1 # tab-local
let s:script_var = 1 # script-local (this file only)
let l:local_var = 1 # function-local
let v:count # built-in Vim variable
# Constants (Vim 8+):
const PI = 3.14159
let g:CONFIG = #{name: "vim"} # locked dictionary
# Check if a variable exists:
if exists('var')
if exists('g:plugin_var')
# String interpolation (Vim 8.2+):
let name = "World"
echo $"Hello, {name}!"Funktionen
function! Name(args) ... endfunction definiert eine Funktion — das ! erlaubt Neudefinition. a: greift auf Argumente zu; a:000 ist die Liste der variadischen Argumente. Default-Argumente (Vim 8+) nutzen =value. Lambdas (Vim 8+) sind {args -> expr}. function('Name') liefert eine Funcref, die du herumreichen kannst. :call nutzen, um eine Funktion für ihre Nebenwirkungen aufzurufen.
# Define a function:
function! MyFunc(arg1, arg2)
echo a:arg1 . ' ' . a:arg2
return a:arg1 + a:arg2
endfunction
# The ! in function! overrides an existing function
# (without ! Vim errors if function already exists).
# Call a function:
call MyFunc("hello", "world")
let result = MyFunc(1, 2)
# Variadic arguments (...):
function! Sum(...)
let total = 0
for i in a:000
let total += i
endfor
return total
endfunction
# Default arguments (Vim 8+):
function! Greet(name, greeting="Hello")
echo a:greeting . ', ' . a:name
endfunction
# Lambda / anonymous functions (Vim 8+):
let Square = {x -> x * x}
echo Square(5) " 25
# Function as a value:
let Fn = function('MyFunc')
echo Fn(1, 2)Bedingungen & Schleifen
if/elseif/else/endif für Bedingungen. for loop-t über eine Liste (range(N) erzeugt 0..N-1) und kann [key, val]-Paare aus items() entpacken. while/endwhile für Bedingungsschleifen. break/continue funktionieren wie erwartet. Übliche Bedingungsprüfungen: has() für Features, exists() für Variablen/Befehle, filereadable() für Dateien, empty() für leere Werte, type() für Typvergleiche.
# Conditionals:
if x > 10
echo "big"
elseif x > 5
echo "medium"
else
echo "small"
endif
# Ternary:
let result = (x > 0) ? "positive" : "non-positive"
# Loops:
for i in range(5) # 0,1,2,3,4
echo i
endfor
for [key, val] in items({'a': 1, 'b': 2})
echo key . '=' . val
endfor
while x > 0
let x -= 1
endwhile
# Loop control:
break # exit loop
continue # skip to next iteration
# Match-related conditionals:
if has('python3') # feature check
if exists(':Command') # command exists
if filereadable('file') # file is readable
if empty(var) # variable is empty
if type(var) == type([]) # type checkStrings
. konkateniert Strings. Vim 8.2+ ergänzt $"...{expr}..."-Interpolation. len/strlen liefern die Bytelänge; strcharlen die Zeichenzahl (wichtig bei Multibyte). split/join konvertieren zwischen Strings und Listen. substitute() ist der programmatische :s-Befehl. matchstr() extrahiert einen Regex-Match. =~ ist der Regex-Match-Operator.
# String concatenation:
let s = "Hello" . " " . "World"
# String interpolation (Vim 8.2+):
let name = "Vim"
echo $"Welcome to {name}!"
# Common functions:
len("hello") # 5
strlen("hello") # 5 (byte length)
strcharlen("hello") # 5 (char length)
tolower("HELLO") # "hello"
toupper("hello") # "HELLO"
strpart("hello", 1, 3) # "ell" (substring)
matchstr("foo123bar", '\d\+') # "123"
substitute("foo", 'o', '0', 'g') # "f00"
split("a,b,c", ',') # ['a', 'b', 'c']
join(['a', 'b', 'c'], '-') # "a-b-c"
trim(" hello ") # "hello"
# printf-style formatting:
printf("%d + %d = %d", 1, 2, 3) # "1 + 2 = 3"
printf("%05.2f", 3.14159) # "03.14"
# Regex matching:
if "hello" =~ '^h'
echo "starts with h"
endifListen & Dictionaries
Listen sind geordnet (wie Arrays); Dictionaries sind Schlüssel-Wert-Maps. Listen-Slicing nutzt [start:end]. add/insert/remove ändern Listen in place. sort/reverse mutieren ebenfalls. Bei Dicts funktionieren sowohl .key als auch ["key"] als Zugriff; keys()/values()/items() liefern Listen. has_key() prüft die Mitgliedschaft. #{...} (Vim 8+) ist ein saubereres Dict-Literal, das keine Schlüsselquotierung verlangt.
# Lists (like arrays):
let nums = [1, 2, 3, 4, 5]
echo nums[0] # 1 (first)
echo nums[-1] # 5 (last)
echo nums[1:3] # [2, 3, 4] (slice)
# List operations:
call add(nums, 6) # append 6
call insert(nums, 0, 0) # insert 0 at index 0
call remove(nums, 0) # remove index 0
echo len(nums) # length
call sort(nums) # sort in place
call reverse(nums) # reverse in place
call extend(nums, [7, 8]) # concatenate
# Iterate:
for n in nums
echo n
endfor
# Dictionaries (like hash maps / objects):
let d = {"name": "Vim", "version": 9}
echo d.name # "Vim"
echo d["version"] # 9
let d.lang = "Vimscript" # add a key
call remove(d, "version") # remove a key
echo keys(d) # ['name', 'lang']
echo values(d) # ['Vim', 'Vimscript']
echo items(d) # [['name', 'Vim'], ['lang', 'Vimscript']]
echo has_key(d, "name") # 1 (true)
# Dictionary literal (Vim 8+, cleaner):
let d2 = #{key: "value", count: 42}Autocmds & eigene Befehle
autocmd führt Code bei Vim-Events aus (BufRead, BufWritePre, FileType, VimEnter, CursorMoved usw.). Autocmds immer in augroup mit autocmd! wickeln, um alte Definitionen beim Neuladen zu leeren — verhindert Duplizierung. Eigene Befehle nutzen :command! -nargs=N -range -bang Name action. <args>, <line1>, <line2>, <bang> greifen in der Befehlsdefinition auf die Nutzereingabe zu.
# Autocmds: run code on events
:autocmd BufWritePre *.md :%s/\s\+$//e " trim trailing whitespace
# Group autocmds (recommended - prevents duplicates on reload):
augroup markdown_settings
autocmd!
autocmd BufRead,BufNewFile *.md setlocal spell
autocmd FileType markdown setlocal textwidth=80
autocmd BufWritePre *.md :%s/\s\+$//e
augroup END
# Common events:
# BufReadPost - after loading a file
# BufWritePre - before saving
# BufWritePost - after saving
# FileType - when filetype is set
# VimEnter - after Vim startup
# CursorMoved - cursor moved in normal mode
# InsertEnter - entering insert mode
# Custom Ex commands:
command! -nargs=1 Grep !grep <args> %
command! -range Sum echo <line1> + <line2>
command! -bang Q quit<bang>
# Use them:
:Grep pattern
:Sum
# Show all autocmds:
:autocmd
# Show autocmds for a specific event:
:autocmd BufWritePreVerwandte Vim-Snippets
Copy-paste ready code for common tasks.
Buffer, Windows & Tabs
Mehrere Dateien mit Buffern, geteilten Windows und Tabs bearbeiten.
Suchen & Ersetzen
Text mit / finden und mit :s ersetzen, mit Regex und Ranges.
Register (Multi-Clipboard)
Yanks/Deletes in benannten Registern speichern und daraus einfügen.
Marks (Lesezeichen)
Zu Positionen in einer Datei oder zwischen Dateien mit Marks zurückspringen.
Makros (Tastenaufzeichnungen)
Eine Tastensequenz aufzeichnen und abspielen, um wiederholte Edits zu automatisieren.
Folding (Code einklappen)
Code-Regionen ausblenden, um sich auf die Struktur zu konzentrieren, mit Fold-Methoden.
Plugin-Manager & Ökosystem
Plugins mit vim-plug / packer / lazy installieren, konfigurieren und entdecken.
LSP, Completion & Diagnosen
IDE-Features (Autovervollständigung, Go-to-Definition, Diagnosen) via LSP erhalten.
Was this helpful?