Argument-List

Was die Argument-List ist

Die Argument-List (kurz: arglist) ist eine geordnete Liste von Dateinamen, die für eine Vim-Session als „Arbeits-Set" gilt. Sie hat drei Hauptquellen:

1. CLI-Argumente beim Start: vim foo.txt bar.txt baz.txt setzt die arglist auf diese drei Dateien.
2. :args-Befehl zur Laufzeit: :args src/*.go setzt die arglist neu.
3. :argadd zum nachträglichen Erweitern.

Die arglist ist getrennt von der Buffer-List. Sie kann eine echte Teilmenge der Buffer sein, eine Obermenge oder etwas ganz anderes — abhängig davon, was zwischenzeitlich passiert ist.

" Vim mit drei Dateien starten
vim foo.txt bar.txt baz.txt

" arglist enthält:    foo.txt, bar.txt, baz.txt (3 Einträge)
" buflist enthält:    foo.txt (nur die erste ist tatsächlich geladen)

" :next geht durch die arglist:
:next                " bar.txt — wird jetzt auch in buflist geladen
:next                " baz.txt — buflist hat jetzt alle drei

" :e qux.txt fügt qux zur buflist hinzu, NICHT zur arglist:
:e qux.txt           " arglist: drei Einträge (unverändert)
                     " buflist: vier Einträge

Dieser Unterschied ist die zentrale Idee: die arglist ist eine bewusst gewählte, kuratierte Liste für eine bestimmte Operation, die buflist ist der Speicherzustand „alles, was gerade offen ist". Beide haben ihren Zweck, beide sind unabhängig manipulierbar.

:args — anzeigen und setzen

Das zentrale Kommando:

Die Glob-Syntax ist Vims eigene, ähnlich zu Shell-Globbing:

• * matched alles außer /
• ** matched rekursiv inklusive Pfad-Trenner
• ? matched genau ein Zeichen
• [abc] matched eines der Zeichen

:args ohne Argument zeigt die aktuelle Liste, die aktuelle Datei in eckigen Klammern markiert:

:args
" Ausgabe:
" foo.txt  [bar.txt]  baz.txt
"          ↑ die aktuelle Datei in eckigen Klammern

Mit :args plus Argument wird die arglist neu gesetzt — die alte ist verloren. Wer additiv arbeiten will, nutzt :argadd (siehe nächster Abschnitt).

arglist erweitern und reduzieren

Drei zusätzliche Befehle für inkrementelle Manipulation:

:argadd ist im Alltag wichtiger als :args: er erweitert die existierende Liste, statt sie zu ersetzen. Damit kann man ein Arbeits-Set schrittweise aufbauen:

:args src/auth/*.go      " Auth-Modul-Dateien als Start
:argadd src/db/*.go      " DB-Dateien dazu
:argadd tests/auth_test.go  " spezifische Test-Datei dazu
:args                    " jetzt die kombinierte Liste prüfen

Durch die arglist navigieren

Vim hat eine eigene Befehlsfamilie für arglist-Navigation, parallel zu den Buffer-Befehlen:

:next und :prev öffnen die nächste/vorherige Datei aus der arglist im aktuellen Fenster. Sie verhalten sich strukturell wie :bnext/:bprev, beziehen sich aber auf die arglist, nicht auf die buflist.

Mit :argument 3 springst du direkt zur dritten Datei in der arglist — eine spezifische Navigation, die mit :b über Namen oft umständlicher wäre.

:argdo — der eigentliche Hebel

Das wichtigste Argument-List-Werkzeug ist :argdo — es führt einen Ex-Befehl auf jeder Datei in der arglist aus, in der Reihenfolge der Liste.

:args src/*.go
:argdo %s/old_var/new_var/ge | update
" Erklärung:
" - %s/old_var/new_var/ge: in jeder Datei alle Vorkommen ersetzen
"   e = no error wenn pattern nicht gefunden
" - update: speichern, falls modifiziert (statt :w, das immer schreibt)

:args **/*.md
:argdo set fileformat=unix | update
" Zeilenende auf unix-Format setzen für alle Markdown-Files

Das | update am Ende des Befehls speichert nach jeder Operation. Ohne diese Kette würde Vim nach :argdo %s/.../.../ge alle Dateien modifiziert im Speicher haben — und sich beim Beenden über ungespeicherte Änderungen beschweren.

Eine Variante mit Bestätigung pro Stelle: das c-Flag bei :substitute:

:args src/*.go
:argdo %s/old_var/new_var/gec | update
" e = no error, c = confirm vor jeder Ersetzung

Mit c fragt Vim bei jeder Stelle einzeln nach (y/n/a/q/l) — präzise Kontrolle über sehr große Refactoring-Operationen.

Voraussetzung für :argdo — set hidden

:argdo kann nur funktionieren, wenn Vim zwischen den Dateien wechseln darf, ohne dass die Modifikationen explizit gespeichert werden müssen. Ohne set hidden (siehe Buffer-Konzept) würde Vim beim ersten Wechsel mit modifizierter Datei stehen bleiben:

E37: No write since last change

Mit set hidden werden modifizierte Buffer hidden, Vim wechselt durch, am Ende ist die Datei-Liste komplett modifiziert. Das | update im obigen Beispiel sichert jeden Schritt ab.

In Vim-Konfigs ist die typische Kombination deshalb:

set hidden               " erlaubt Buffer-Wechsel mit modifizierten Dateien
set autowrite            " optional: speichert automatisch beim Wechsel

autowrite ist eine Alternative zu | update — Vim speichert vor jedem Wechsel automatisch. Im Alltag mit :argdo reicht die manuelle Variante mit | update, weil sie explizit kontrolliert, was gespeichert wird.

arglist vs. buflist — wann was

Beide Listen haben überlappende Funktionen. Eine Faustregel zur Wahl:

Im Klartext: die buflist ist die flüssige, sich ständig ändernde Liste; die arglist ist die bewusst gewählte, stabile Liste für eine spezifische Aufgabe. Wer nicht aktiv arglist-Befehle nutzt, kommt mit der buflist auch klar — aber wer Mass-Edits über vorausgewählte Datei-Sätze macht, hat in der arglist das passendere Werkzeug.

Workflow-Muster

Drei typische arglist-Anwendungen:

Refactoring über ein Modul

" 1. arglist auf das betroffene Modul setzen
:args src/auth/*.go

" 2. Alle Stellen in einem Buffer prüfen
:first               " zur ersten Datei
/OldName             " erste Stelle finden — Cursor draufsetzen
cwNewName<Esc>       " ändern

" 3. Bulk-Operation auf den Rest:
:argdo %s/OldName/NewName/ge | update

" 4. Mit :next und :prev kontrollieren, ob alles korrekt ist
:first
:next | :next | ...

arglist aus externer Tool-Ausgabe

" arglist auf alle Dateien setzen, die ripgrep findet
:args `rg --files-with-matches 'TODO' src/`

" Jetzt :argdo auf der gefilterten Liste
:argdo /TODO<CR> | update

Das ist die Kombination, die :argdo zum mächtigsten Bulk-Edit-Werkzeug macht: man baut die Liste mit einem externen Tool (find, rg, fd, git ls-files) und wirkt anschließend per Vim-Befehl.

Vim-Start als gezielte Arbeits-Session

# Vim mit allen Test-Dateien starten
vim $(find tests -name '*_test.go')

# Oder mit fd:
vim $(fd -e go --type f .)

# Innerhalb von Vim ist arglist dann schon gesetzt:
# :args zeigt sie, :argdo wirkt auf sie

Das ist eine elegante Variante: die Arbeits-Datei-Liste wird in der Shell ausgewählt, Vim startet mit ihr als arglist, alle weiteren Operationen sind direkt verfügbar.

Weiterführende Ressourcen

Externe Quellen

• Vim Help: argument-list — vollständige arglist-Referenz.
• Vim Help: :args — Setz- und Anzeige-Befehl.
• Vim Help: :argdo — Bulk-Operationen.
• Vim Help: :next — Navigation in der arglist.
• Drew Neil — Practical Vim, Tip 38 — „Run Ex Commands Across Multiple Buffers".

Verwandte Artikel

• Das Buffer-Konzept
• Buffer wechseln
• Fenster und Splits
• Tabs richtig verstehen
• Suche und Ersetzen
• Quickfix und Location-List