Vim - Faltungen & Folds mit z - einfach

Was Folds überhaupt sind

In Vim sind Folds zusammen- und ausklappbare Bereiche in einem Textdokument. Du kannst damit ganze Absätze, Funktionen oder Codeblöcke zusammenklappen, so dass nur die erste Zeile sichtbar bleibt. Das macht das Navigieren in umfangreichen Dateien deutlich einfacher.

Die Eselsbrücke für den Befehl ist einfach. Alle Fold-Kommandos beginnen mit z, weil das z aussieht wie ein gefaltetes Stück Papier von der Seite betrachtet.

Die sechs Fold-Methoden

Vim bietet sechs verschiedene Methoden, wie Faltungen erstellt werden. Du stellst sie mit :set foldmethod=METHODE ein oder trägst sie dauerhaft in deine ~/.vimrc ein.

manual - Du erstellst Faltungen selbst mit zf, für unstrukturierte Texte:
indent - Einrückung bestimmt die Faltungstiefe, ideal für Programmcode
expr - Faltungen werden durch einen Ausdruck definiert, für Log-Dateien oder spezielle Filter
syntax - Syntax-Highlighting definiert die Faltungen, ideal für Programmcode
diff - Unveränderter Text wird gefaltet
marker - Marker im Text wie {{{ und }}} definieren Faltungen

Für den Alltag sind indent für Code und manual für alles andere die praktischsten Methoden.

foldlevel - Die Faltungstiefe steuern

Die Option foldlevel legt fest, wie viele Ebenen von Faltungen gleichzeitig geöffnet oder geschlossen sind. Sie ist die zentrale Steuerung für die Faltungstiefe im aktuellen Fenster .

Die typischen Werte

foldlevel=0 - Alle Faltungen sind geschlossen. Du siehst nur die äußerste Struktur, zum Beispiel Kapitelüberschriften oder Top-Level-Funktionen
foldlevel=1 - Nur die oberste Ebene ist aufgeklappt, darunterliegende Faltungen bleiben geschlossen. Gut für einen Überblick über die Hauptblöcke
foldlevel=2 - Zwei Ebenen sind sichtbar, tiefere Faltungen bleiben zu. Praktisch für verschachtelte Code-Strukturen
foldlevel=99 - Praktisch alles ist geöffnet. Nur explizit geschlossene Faltungen bleiben zu

foldlevel vs. foldlevelstart

Ein wichtiger Unterschied: foldlevel gilt für das aktuelle Fenster und wirkt sofort. foldlevelstart legt fest, mit welcher Faltungstiefe eine Datei geöffnet wird .

Wenn du also möchtest, dass eine Datei beim Öffnen komplett aufgeklappt ist, setzt du foldlevelstart=99 in deiner ~/.vimrc .

Wichtige Befehle

:set foldlevel? zeigt den aktuellen Wert an
:setlocal foldlevel=1 setzt die Tiefe nur für das aktuelle Fenster
2zM schliesst alle Faltungen bis Ebene 2, lässt Ebene 1 offen

Faltungen dauerhaft speichern

Ein wichtiger Punkt, den viele nicht wissen. Wenn du eine Datei schliesst, gehen manuell erstellte Faltungen verloren. Vim merkt sich den Zustand nicht automatisch.

Dafür gibt es die Befehle :mkview und :loadview. Mit :mkview speicherst du den aktuellen Zustand inklusive der Faltungen. Wenn du die Datei später wieder öffnest, lädst du mit :loadview alles zurück. Du kannst bis zu zehn verschiedene Ansichten pro Datei speichern.

Speicherort Faltungen

Vim speichert die Ansichten in dem Verzeichnis, das in der Option viewdir definiert ist. Der Standardwert hängt von deinem Betriebssystem ab:

Linux und Unix (auch macOS): ~/.vim/view
Windows: $VIM/vimfiles/view

In diesem Ordner legt Vim für jede Datei eine eigene View-Datei ab. Der Dateiname wird dabei aus dem Pfad der Originaldatei generiert, wobei Sonderzeichen durch Gleichheitszeichen (=) ersetzt werden .

Den aktuellen Speicherort herausfinden

Du kannst dir den Pfad direkt in Vim anzeigen lassen:

:set viewdir?

Die Ausgabe zeigt dir, wo Vim aktuell sucht oder speichert .

Speicherort ändern

Wenn du den Standardpfad ändern möchtest (zum Beispiel um dein Home-Verzeichnis sauber zu halten), kannst du die Option in deiner ~/.vimrc anpassen:

set viewdir=~/.vim/meine-views

Bei neueren Vim-Versionen respektiert der Standardwert mittlerweile auch die XDG_CONFIG_HOME-Umgebungsvariable und nutzt dann ~/.config/vim/view .

View-Dateien löschen

Da es keinen eingebauten Befehl zum Löschen gibt, musst du die Dateien manuell entfernen. Navigiere dazu einfach in den oben genannten Ordner und lösche die entsprechenden Dateien .

Die wichtigsten Befehle für den Alltag

Die grundlegenden Befehle solltest du kennen, dann kommst du schon sehr weit.

Öffnen und Schliessen

zo öffnet eine Faltung unter dem Cursor (open)
zc schliesst eine Faltung unter dem Cursor (close)
za klappt die Faltung um, öffnet wenn geschlossen, schliesst wenn offen (alternate)
zR öffnet alle Faltungen im Dokument (Reset)
zM klappt alle Faltungen zu im Dokument (Minimize)

Kombination mit den klassischen Navigationsbefehlen:

zj springt zur nächsten Faltung
zk springt zur vorherigen Faltung
[z springt zum Anfang der aktuellen Faltung
]z springt zum Ende der aktuellen Faltung

Erstellen und Löschen

zf gefolgt von einer Bewegung erstellt eine Faltung, zum Beispiel zfap für einen ganzen Absatz (fold)
zd löscht die Faltung unter dem Cursor, der Text bleibt erhalten (delete)
zE löscht alle Faltungen im Fenster (Eliminate)

Praktische Beispiele - Faltungsmethoden

Vim bietet sechs verschiedene Methoden, um Faltungen zu erstellen. Welche du wählst, hängt davon ab, was du bearbeitest und wie viel Kontrolle du haben möchtest.

manual - Manuelles Falten mit `zf`

Die direkteste Methode. Du markierst einen Bereich und faltest ihn mit zf. Das funktioniert visuell, mit Bewegungen oder mit Klammern.

Visuell markieren und falten

Markiere den Bereich mit v (zeichenweise), V (zeilenweise) oder Strg-v (blockweise)
Drücke zf

Vim erstellt daraus eine Faltung. Der Text bleibt erhalten, wird nur versteckt .

Mit Bewegungen falten

zfap faltet einen ganzen Absatz (absatz packen - a paragraph)
zfG faltet vom Cursor bis zum Ende der Datei (Ganz unten - Go to end)
zfgg faltet vom Dateianfang bis zum Cursor (geh ganz hoch)

Zwischen Klammern falten

Der eleganteste Weg für Code. Setz den Cursor auf eine öffnende Klammer wie { oder [ und drücke zf%. Vim springt zur passenden schliessenden Klammer und faltet alles dazwischen .

Ein Beispiel in einer JavaScript-Datei:

function berechneSumme(a, b) {
  const ergebnis = a + b;
  console.log(ergebnis);
  return ergebnis;
}

Mit dem Cursor auf der öffnenden { und zf% sieht es danach so aus:

+-- 4 lines: function berechneSumme(a, b) {

indent - Faltung durch Einrückung

Für Code die praktischste Methode. Vim erstellt automatisch Faltungen basierend auf der Einrückungstiefe .

:set foldmethod=indent

Jede Ebene der Einrückung wird zu einer Faltungsebene. Beim Öffnen einer Datei mit foldlevel=1 sind alle Funktionen eingeklappt und du siehst nur die Struktur auf einen Blick.

marker - Faltung durch Marker

Du setzt spezielle Markierungen in den Text, die Vim als Faltungsgrenzen erkennt. Die Standard-Marker sind {{{ und }}} .

:set foldmethod=marker

Ein Beispiel:

<!-- {{{ -->
<div class="container">
  <p>Erste Zeile</p>
  <p>Zweite Zeile</p>
</div>
<!-- }}} -->

Der Text zwischen den Markern wird zu einer Faltung. Der Vorteil: Die Faltung bleibt beim erneuten Öffnen der Datei erhalten. Der Nachteil: Du veränderst die Datei selbst.

syntax - Faltung durch Syntax

Vim nutzt die vorhandenen Syntax-Regeln, um Faltungen zu erstellen. Für die meisten Programmiersprachen sind diese Regeln bereits vorhanden .

:set foldmethod=syntax

Bei Ruby-Code werden beispielsweise alle Methoden automatisch gefaltet. Du musst nichts weiter konfigurieren.

expr - Faltung durch Ausdruck

Die flexibelste Methode. Du definierst einen Ausdruck, der für jede Zeile entscheidet, ob sie gefaltet wird .

:set foldmethod=expr
:set foldexpr=getline(v:lnum)=~'ERROR'

Dieses Beispiel faltet alle Zeilen, die nicht das Wort ERROR enthalten. Ideal für Log-Dateien, um nur die Fehler sichtbar zu lassen.

diff - Faltung durch diff

Wenn du zwei Versionen einer Datei vergleichst, werden unveränderte Bereiche automatisch gefaltet. Diese Methode wird meist automatisch aktiviert, wenn du vimdiff oder :diffthis verwendest.

Praktische Anwendung

Für Code-Dateien nutze ich meist foldmethod=indent in Kombination mit foldlevel=1. Dann sind beim Öffnen einer Datei alle Funktionen eingeklappt und ich sehe nur die Struktur auf einen Blick. Mit za klappe ich dann die Funktion auf.

Für längere Textdokumente ist foldmethod=manual oft besser. Dann kann ich selbst entscheiden, welche Absätze ich zusammenklappe.

Und wenn dir die Faltungen mal zu viel werden, dann hilft zR oder zn, um alles wieder zu öffnen.

Quellen

Vim ist als Open-Source-Software verfügbar.

Webseite: https://www.vim.org/
Vim Dokumentation Folding: https://vimhelp.org/fold.txt.html
Vim User Manual Folding: https://vimhelp.org/usr_28.txt.html
Vim Folding Wiki: https://vim.fandom.com/wiki/Folding

Alte Views löschen - Vimscript

Hier ist ein Vimscript, das verwaiste View-Dateien findet und löscht, sowie eine Anleitung zum Einbinden.

Das Skript nutzt die Funktionen readdir() zum Auflisten des View-Ordners und delete() zum Löschen der Dateien . Die Umkehrung der Namenskonvention (=+ zu /) ist der Kern der Prüfung.

Die Umkehrung der Namenskonvention

Das ist der entscheidende Punkt. Vim speichert View-Dateien nicht unter dem Originalnamen, sondern kodiert den vollständigen Pfad in den Dateinamen. Dabei wird jeder Schrägstrich (/) durch die Zeichenfolge =+ ersetzt.

Ein Beispiel. Die Originaldatei /home/user/test.txt wird zu einer View-Datei mit dem Namen =+home=+user=+test.txt im View-Ordner.

" Funktion zum Bereinigen verwaister View-Dateien
function! s:CleanOrphanedViews()
    " Ermittle das View-Verzeichnis (Standard: ~/.vim/view)
    let view_dir = expand(&viewdir)
    
    " Prüfe, ob das View-Verzeichnis existiert
    if !isdirectory(view_dir)
        echohl WarningMsg
        echo "View-Verzeichnis nicht gefunden: " . view_dir
        echohl None
        return
    endif

    let orphaned_count = 0
    
    " Alle Dateien im View-Verzeichnis auflisten
    for view_file in readdir(view_dir)
        let view_path = view_dir . '/' . view_file
        
        " Nur Dateien verarbeiten (keine Unterordner)
        if !filereadable(view_path)
            continue
        endif

        " Den Dateinamen zurück in einen Pfad umwandeln
        " Vim ersetzt '/' durch '=+' im Dateinamen
        let original_path = substitute(view_file, '=+', '/', 'g')
        
        " Prüfen, ob die Originaldatei noch existiert
        " filereadable() ist robuster als glob() bei Berechtigungsproblemen 
        if !filereadable(original_path)
            " Datei existiert nicht mehr -> View löschen
            if delete(view_path) == 0
                let orphaned_count += 1
                echom "Verwaiste View gelöscht: " . view_file
            else
                echohl WarningMsg
                echom "Fehler beim Löschen: " . view_file
                echohl None
            endif
        endif
    endfor

    " Zusammenfassung ausgeben
    if orphaned_count > 0
        echom "Bereinigung abgeschlossen: " . orphaned_count . " verwaiste View(s) gelöscht."
    else
        echom "Keine verwaisten View-Dateien gefunden."
    endif
endfunction

" Befehl zum Aufrufen der Funktion definieren
command! CleanViews call s:CleanOrphanedViews()

Wie das Skript funktioniert

Verzeichnis ermitteln: Das Skript liest die globale Option &viewdir aus, die standardmäßig auf ~/.vim/view (Unix) oder $VIM/vimfiles/view (Windows) zeigt.
Dateien auflisten: Mit readdir() werden alle Einträge im View-Ordner gelesen .
Pfad rekonstruieren: Der entscheidende Schritt. Vim kodiert den Originalpfad im View-Dateinamen, indem es jeden Schrägstrich (/) durch die Zeichenfolge =+ ersetzt. Die Funktion substitute() macht diese Ersetzung rückgängig.
Existenzprüfung: filereadable() prüft, ob die so rekonstruierte Originaldatei noch vorhanden und lesbar ist . Dies ist robuster als eine reine glob()-Prüfung, falls Berechtigungen im Spiel sind .
Löschen: Wenn die Originaldatei fehlt, wird die View-Datei mit der eingebauten delete()-Funktion entfernt .

Einbindung in die Vim-Konfiguration

Du hast zwei Möglichkeiten, das Skript dauerhaft zu nutzen.

Option 1: Direkt in die .vimrc einfügen

Kopiere den gesamten Codeblock in deine ~/.vimrc (oder ~/.config/nvim/init.vim). Nach dem Speichern und Neustarten von Vim kannst du den Befehl :CleanViews verwenden.

Option 2: Als separates Plugin (empfohlen für Ordnung)

Erstelle eine Datei namens cleanviews.vim im Verzeichnis ~/.vim/plugin/.
Füge den Code dort ein.
Vim lädt Dateien in ~/.vim/plugin/ beim Start automatisch.

In beiden Fällen steht der Befehl :CleanViews zur Verfügung. Er gibt nach dem Lauf eine Meldung aus, wie viele verwaiste View-Dateien gelöscht wurden.

Was Folds überhaupt sind#

Die sechs Fold-Methoden#

foldlevel - Die Faltungstiefe steuern#

Die typischen Werte#

foldlevel vs. foldlevelstart#

Wichtige Befehle#

Faltungen dauerhaft speichern#

Speicherort Faltungen#

Den aktuellen Speicherort herausfinden#

Speicherort ändern#

View-Dateien löschen#

Die wichtigsten Befehle für den Alltag#

Öffnen und Schliessen#

Navigation zwischen Faltungen#

Erstellen und Löschen#

Praktische Beispiele - Faltungsmethoden#

manual - Manuelles Falten mit zf#

indent - Faltung durch Einrückung#

marker - Faltung durch Marker#

syntax - Faltung durch Syntax#

expr - Faltung durch Ausdruck#

diff - Faltung durch diff#

Praktische Anwendung#

Quellen#

Alte Views löschen - Vimscript#

Die Umkehrung der Namenskonvention#

Wie das Skript funktioniert#

Einbindung in die Vim-Konfiguration#