Skip to content

Vim Spickzettel

Stark konfigurierbarer Texteditor für effizientes Textbearbeiten.

01

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
# 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 42

Beenden & 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.

vim
: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').

vim
: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 directory

Wort- & 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).

vim
# 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.

vim
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.

vim
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 bottom
02

Text 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.

vim
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').

vim
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 three

Change-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).

vim
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.

vim
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.

vim
: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 digraphs

Insert-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.

vim
# 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 inserting
03

Bearbeitungsbefehle (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.

vim
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.

vim
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.

vim
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.

vim
~      # 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  ->  HELLO

Zeilen 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.

vim
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=80

Wiederholen & 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.

vim
.        # 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 line
04

Suche & 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.

vim
/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.

vim
: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 match

Suchmuster (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.

vim
# 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 digits

Substitute-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.

vim
:[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-magic

Substitute-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.

vim
# 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 only

Globaler 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.

vim
:[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 |)
05

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.

vim
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     ->  blockwise

Visual-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.

vim
# 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-filled

Visual-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.

vim
# 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.

vim
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 visual

Visual 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.

vim
# 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 parens

Visual-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.

vim
# 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-a
06

Buffers

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.

vim
: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
#   +   modified

Buffer-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.

vim
: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).

vim
: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.

vim
: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.

vim
# 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.

vim
: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)
07

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.

vim
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.

vim
\`{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.

vim
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 :clj

Changelist

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.

vim
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 edits

Datei-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.

vim
# 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.

vim
\`.    # 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 mode
08

Text-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.

vim
# 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 word

Klammer-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).

vim
# 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 innermost

Anfü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.

vim
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 too

Satz- & 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.

vim
# 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 start

Tag- & 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).

vim
# 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.

vim
# 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 words
09

Register

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.

vim
# 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' contents

Benannte & 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.

vim
# 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.

vim
# 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.

vim
# 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 line

Anhä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.

vim
# 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.

vim
# 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 Wayland
10

Makros

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.

vim
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.

vim
@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 times

Makros 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.

vim
# 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' contents

Rekursive 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.

vim
# 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 file

Makros 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.

vim
# 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 file

Makros ü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!).

vim
# 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).
11

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.

vim
: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 saves

Manuelles 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.

vim
# 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.

vim
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 folds

Fold-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).

vim
# 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 region

Fold-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.

vim
: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 loadview

Verschachtelte 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.

vim
# 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)'
endfunction
12

Geteilte 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).

vim
: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.

vim
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' buffers

Fenstergröß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.

vim
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-resize

Fensterverschiebung

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.

vim
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 tab

Fensteranordnung

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.

vim
# 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 window

Fenster 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.

vim
: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.
13

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).

vim
: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.).

vim
: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 windows

Tab-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.

vim
: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.

vim
# 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.

vim
: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.

vim
: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)
14

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.

vim
# 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.

vim
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.

vim
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 lines

Sucheinstellungen

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.

vim
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:
:nohlsearch

Anzeigeeinstellungen

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.

vim
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 solarized

Tasten 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.

vim
# 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>
15

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.

vim
# 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.

vim
: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.

vim
" 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.

vim
" 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 loading

Plugin-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.

vim
" 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.

vim
" 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)
16

Suche & Navigation

Eingebaute Suche

Die eingebaute Suche nutzt / und ? mit Vim-Regex (\v für very-magic nutzen). Suchoffsets (/foo/e platziert den Cursor am Match-Ende) halten über n/N hinweg — nützlich, um den Cursor nach jedem Match an die richtige Stelle zu setzen. \%V begrenzt eine Suche auf die aktuelle visuelle Auswahl. / und dann Pfeil-auf ruft die Suchhistorie ab; :history / listet sie.

vim
/pattern      # search forward
?pattern      # search backward
n / N         # next / previous match
* / #         # search word under cursor (forward / backward)
g* / g#       # search word under cursor (substring match)

# Search with offsets:
/foo/e        # cursor on last char of match
/foo/e+1      # cursor 1 char past match
/foo/b-1      # cursor 1 char before match
/foo/s+2      # cursor 2 chars after start of match

# Search in current visual selection:
# 1. Visually select (v/V/Ctrl-v)
# 2. Press /  ->  search forward
# 3. Pattern auto-confines to selection? NO.
#    Workaround: /\%Vpattern  (\%V = inside visual selection)

# Repeat last search:
/ then Up arrow    # recall from history
:history /         # list search history

# Search offset persists with n/N.

grep mit Quickfix

:grep führt ein externes grep aus (konfigurierbar über 'grepprg') und legt die Ergebnisse in die Quickfix-Liste. :copen zeigt die Liste; :cn/:cp navigieren. grepprg=rg --vimgrep setzen lässt es ripgrep nutzen — viel schneller als grep, mit besseren Defaults. :cdo führt einen Ex-Befehl auf jedem Quickfix-Eintrag aus — perfekt für Massensubstitutionen über Treffer hinweg.

vim
# Built-in :grep (uses external grep):
:grep pattern *.py        # search Python files
:grep -r pattern .        # recursive search
:grepadd pattern *.c      # append to existing quickfix list

# After :grep, results appear in the quickfix window:
:copen / :cw   # open quickfix window (cw only if non-empty)
:cnext / :cn   # next match
:cprev / :cp   # previous match
:cfirst / :clast  # first / last match
:cc N          # jump to match N
:cclose        # close quickfix window
:clist         # list all matches (no window)

# Customize the grep program:
:set grepprg=rg\ --vimgrep   " use ripgrep instead
:set grepformat=%f:%l:%c:%m,%f:%l:%m

# With ripgrep, super fast:
:grep pattern   # uses grepprg

# Multi-file edit from quickfix:
:cdo s/old/new/ge | update

vimgrep

:vimgrep nutzt Vims interne Suchmaschine — langsamer als externes grep, aber portabel (funktioniert auf jedem OS ohne externe Tools) und nutzt Vim-Regex-Syntax. Das Muster steht zwischen //-Begrenzern; **/*.py matcht Python-Dateien rekursiv. Ergebnisse füllen die Quickfix-Liste — :copen zum Ansehen, :cn/:cp zum Navigieren. :vimgrepadd nutzen, um an eine bestehende Liste anzuhängen.

vim
# :vimgrep uses Vim's internal search (slower than
# external grep, but uses Vim regex and works everywhere).

:vimgrep /pattern/ **/*.py     # search recursively
:vimgrep /pattern/ *.txt       # current directory
:vimgrep /pattern/ file.txt    # single file
:vimgrep /\cFoo/ **/*          # case-insensitive

# Append to existing list:
:vimgrepadd /pattern/ *.c

# Open results in quickfix:
:copen

# Notes:
#   - ** means recursive
#   - Pattern uses Vim regex (same as /search)
#   - Slower than external grep (loads each file into Vim)
#   - Works without external tools (portable)

# Limit search to current buffer only:
:vimgrep /pattern/ %

# Search in visual selection across files: not directly,
# use :grep or external tool instead.

# Jump directly to first match (skip quickfix):
#   :vimgrep /pattern/ **/* | cfirst

ctags-Integration

ctags erzeugt einen Index von Bezeichnern (Funktionen, Klassen usw.), den Vim für Codenavigation nutzt. Ctrl-] springt zur Definition unter dem Cursor; Ctrl-T springt zurück. :ts listet passende Tags bei Mehrdeutigkeit. ctags -R . im Projektstamm ausführen, um Tags zu erzeugen. `set autochdir` ergänzen oder den 'tags'-Pfad konfigurieren für projektbewusste Navigation.

vim
# Generate tags file (run in shell):
#   ctags -R .
# (or with Universal Ctags for more languages)

# In Vim, the tags file is auto-read from 'tags' option:
:set tags?        # default: ./tags,./TAGS,tags,TAGS

# Jump to definition (uses tags):
Ctrl-]            # jump to tag under cursor
:tag funcname     # jump to specific tag
:ts funcname      # list matching tags, pick one
:tn / :tp         # next / previous matching tag
:tl               # last tag
Ctrl-T            # pop back from tag jump
:tags             # show tag stack
:pop              # same as Ctrl-T

# Split window before jumping:
Ctrl-W ]          # split, then jump to tag
:stag funcname    # split, then jump

# Preview tag (open in preview window):
Ctrl-W }          # preview tag under cursor
:ptag funcname    # preview specific tag

# Regenerate tags from inside Vim:
:!ctags -R .

cscope-Integration

cscope liefert mehr Codenavigation als ctags — er findet Aufrufer, Aufgerufene und Include-Beziehungen, nicht nur Definitionen. Bauen mit `cscope -Rb`. In Vim verlinkt :cscope add die Datenbank, dann fragt :cs find X symbol sie ab. Kombiniert mit cscopequickfix füllen Ergebnisse die Quickfix-Liste für einfache Navigation.

vim
# Build cscope database (shell):
#   cscope -Rb       # creates cscope.out
# Or:
#   find . -name '*.c' > cscope.files
#   cscope -b

# In Vim, add the database:
:cscope add cscope.out
:cscope add /path/to/cscope.out /path/to/project

# Query types (use :cs find X symbol):
#   0 or s: symbol (this token)
#   1 or g: definition (same as Ctrl-])
#   2 or d: functions called by this function
#   3 or c: functions calling this function
#   4 or t: string (text)
#   6 or e: egrep pattern
#   7 or f: file
#   8 or i: includes (files #including this file)

:cs find 0 main         # find symbol 'main'
:cs find 3 myfunc       # find callers of myfunc
:cs find e pattern      # egrep search

# Auto-jump on result:
:set cscopequickfix=s-,c-,d-,i-,t-,e-,g-,f-

# Reset connection:
:cscope reset
:cscope kill <connection>

Netrw-Dateibrowser

Netrw ist Vims eingebauter Datei-Explorer — kein Plugin nötig. :Explore öffnet ihn im aktuellen Fenster; :Lexplore schaltet eine linke Seitenleiste um. Innen: Enter zum Öffnen, '-' nach oben, 'D' löschen, 'R' umbenennen, 'd' mkdir, '%' Datei erzeugen. Mit g:netrw_*-Variablen anpassen (Baumansicht, Banner verbergen, Fenstergröße).

vim
# Netrw is Vim's built-in file explorer.

:Explore / :E       # open explorer in current window
:Sexplore / :Sex    # explorer in horizontal split
:Vexplore / :Vex    # explorer in vertical split
:Lexplore / :Lex    # explorer in left-side toggle

# Inside Netrw:
<CR>      # open file/directory
-         # go up one directory
D         # delete file
R         # rename file
d         # create directory
%         # create new file
i         # cycle view (thin/long/wide/tree)
r         # reverse sort
s         # select sort key
x         # open with system viewer
gh        # toggle hidden files
q         # close explorer

# Useful settings:
:let g:netrw_liststyle = 3      # tree view by default
:let g:netrw_winsize = 25       # window size 25%
:let g:netrw_banner = 0         # hide banner

# Toggle explorer:
:nmap <leader>e :Lexplore<CR>
17

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.

vim
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.

vim
(     # 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.

vim
%    # 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.

vim
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 cursor

Scroll-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.

vim
# 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.

vim
: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)
18

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.

vim
# 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' patterns

Dateibefehle

: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).

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 endings

Buffer- & 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.

vim
# 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 file

Optionen 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.

vim
: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).

vim
: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.

vim
:!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 command
19

Vimscript-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}...".

vim
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.

vim
# 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.

vim
# 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 check

Strings

. 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.

vim
# 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"
endif

Listen & 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.

vim
# 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.

vim
# 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 BufWritePre

Was this helpful?