Learning the vi editor

Dieses Buch steht im Regal EDV.

Zusammenfassung des Projekts

Buchpatenschaft / Ansprechperson: Zur Zeit niemand. Buch darf übernommen werden.

Früher: Thopre

Sind Co-Autoren gegenwärtig erwünscht? Ja, sehr gerne.
Hinweis: Buch scheint verwaist zu sein (Hauptautor ist seit 2010 nicht mehr auf WB aktiv).@Thopre: Wenn du noch an dem Buch arbeiten möchtest, dann mache diese Änderung bitte rückgängig.

Historie und Anwendungsbereiche

Vi ist ein Texteditor, der auf nahezu allen Unix-Systemen (und mittlerweile auch auf Windows- bzw. anderen Betriebsystemen) zur Verfügung steht. Vi ist nicht für Textverarbeitung, wie sie beispielsweise für Briefe verwendet wird, gedacht, sondern vielmehr für die Bearbeitung reiner Textdateien.

Typische Anwendungsbereiche sind die Bearbeitung von Quelltexten von Programmen oder Dateien im Bereich der Systemadministration. Grundsätzlich kann man mit vi aber jede Art von Textdateien bearbeiten.

Vi baut auf ex auf. Ex ist eine Erweiterung des ed und arbeitet wie ed zeilenorientiert. Vi ist im Gegensatz zu ex bildschirmorientiert, darum der Name vi visual editor. Vi ist die visuelle Betriebsart des zugrundeliegenden Zeileneditors ex. ed und ex selbst haben heute keine Bedeutung mehr.

Dieser Artikel soll keine vollständige Beschreibung sämtlicher vi-Funktionen sein. Vielmehr soll er als kurze Einführung in die wichtigsten Funktionen des vi dienen. Wer eine Referenz sucht sollte sich mal das Wikibook vi-Befehlsreferenz anschauen.

Erste Schritte

Generell ist unbestreitbar, dass zum Umgang mit vi im Vergleich zu „üblichen“ Editoren eine hohe Eingewöhnungszeit erforderlich ist, die „Gelegenheitsbenutzer“ typischerweise nicht investieren werden. Mitunter fehlt es auch nicht an der Zeit sondern an der Bereitschaft oder einer guten Einführung, die über die Anfangsschwierigkeiten hinweghilft, und vor allem die Motivation zum Weiterlernen aufrecht erhält, bis sich erste Erfolgserlebnisse einstellen.

Spätestens aber, wenn man sich daran gewöhnt hat, Textmuster einfach durch Eingabe eines Schrägstrichs zu suchen, die letzte Suche einfach mit n in der selben oder N in umgekehrter Richtung zu wiederholen, oder auf ganz ähnliche Art Textteile bis zu diesem Muster zu ändern, zu löschen oder zu kopieren, dann erscheinen Menüs und Mausklicks zum selben Zweck umständlich und zeitraubend und ein Pop-Up-Fenster zur Eingabe des Suchmusters, das während der Anzeige der Fundstellen den Blick auf den Textzusammenhang versperrt, wird nur noch als störend empfunden.

Ist der Einstieg erst einmal gelungen, verfügt der Power-User mit dem vi über ein sehr effektives Werkzeug, das viele Konkurrenten wahrscheinlich in den Schatten stellt, selbst wenn diese aufgrund von Menü- und Mausbedienung auf den ersten Blick „besser“ erscheinen mögen. Kommen dann noch gute Kenntnisse anderer Unix-Programme hinzu, hat man mächtige Werkzeuge zur Bewältigung komplexer Editieraufgaben zur Verfügung.

Für den Anfang genügt es eigentlich schon, dass man 5-6 Kommandos kennt um alle nötigen Arbeiten an Dateien zu erledigen - alles weitere ist dann Bequemlichkeit, mit der man sich das Leben etwas erleichtern kann.

Angenommen, wir wollen eine neue Datei namens programm.c bearbeiten. Wir rufen vi mit folgendem Kommando auf:

vi programm.c

Daraufhin erscheint ein leerer Bildschirm (weil die Datei noch nicht vorhanden war) und am unteren Rand etwas wie

"programm.c" [New File]

womit uns vi mitteilt, dass wir im Begriff sind, eine Datei neu anzulegen. Falls die Datei schon existierte, wird natürlich der Inhalt der Datei, bzw. die ersten Zeilen im Fenster angezeigt.

Jetzt ist es wichtig zu wissen, dass vi mit zwei verschiedenen Modi arbeitet (eigentlich gibt es noch einen dritten, aber dazu später): Der Kommandomodus und der Bearbeitungsmodus. Wenn man vi aufruft, befindet man sich erst im Kommandomodus, das heißt, man kann nicht, wie von anderen Editoren gewohnt, an der aktuellen Position gleich losschreiben, sondern muss vi erst sagen, was man machen möchte.

Um beim obigen Beispiel zu bleiben, drücken wir jetzt auf i (für insert). Achtung: vi unterscheidet bei den Kommands streng zwischen Groß- und Kleinschreibung. Ein großes I hat eine andere Bedeutung als ein kleines i. Hiermit kommen wir in den Bearbeitungsmodus. Ein kleines i heißt, füge vor der aktuellen Cursorposition Text ein. Jetzt können wir beispielsweise folgenden Text hintereinander eintippen:

int main () {
   printf ("Hello world\n");
   return 0;
}

Am Schluss drücken wir die ESC-Taste. Mit der Escape-Taste gelangt man vom Bearbeitungsmodus wieder zurück in den Kommandomodus (aber nicht umgekehrt). Wenn du nicht sicher bist, ob du schon wieder zurück im Kommandomodus bist, darfst du die ESC-Taste auch mehrfach betätigen, - das schadet nicht (hat aber außer einem eventuellen Piepston auch keinen Effekt).

Wir sind zurück im Kommandomodus (ESC-Taste) und können versuchen, unsere neue (oder alte) Datei zu speichern. Drücke hierzu ZZ (auch hier ist Groß- und Kleinschreibung wieder relevant). Damit wird die aktuelle Datei gesichert und der Editor verlassen. Das gleiche erreicht man im Kommandomodus mit der Eingabe der Zeichen :x ( oder :wq!).

Gut - damit können wir mit dem vi jetzt schon Text einfügen und speichern. Hilfreich ist es, wenn du quasi im Geiste mitverfolgst, in welchem Modus du gerade bist - sonst führt es bei Anfängern häufig zu Frustration, wenn beispielsweise der Text ZZ mitten im laufenden Text erscheint, weil man vergessen hat, zuerst in den Kommandomodus zurück zu wechseln (weil man mit ZZ eigentlich speichern wollte).

Falls wir festgestellt haben, dass wir im eingegebenen Text Fehler gemacht haben und den Text nicht speichern, sondern die ursprüngliche Version des Textes beibehalten wollen, dann gibt es drei Möglichkeiten, den ursprünglichen Text wieder herzustellen:

1.) Wir verlassen vi im Kommando-Modus nicht mit ZZ, sondern tippen :q! (genau diese drei Zeichen) und bestätigen mit der Return-Taste. Sämtliche Änderungen an der Datei seit dem Öffnen bzw. letzten Speichern werden damit ignoriert.

Hier geschieht etwas Neues: Nach dem Betätigen des ersten Zeichens : (innerhalb von :q!) öffnet sich eine Eingabezeile am unteren Rand unseres Fensters mit einem : als erstem Zeichen - dies ist der sogenannte ex-Modus (s. o.). In dieser Zeile können wir, außer Befehlen zum Speichern, noch verschiedene andere Operationen (wie zum Beispiel das Kopieren oder Verschieben von ganzen Textabschnitten) durchführen. Dazu aber später mehr.

2.) Wir bleiben in der Datei, die wir gerade editieren, indem wir im Kommando-Modus (ESC-Taste) durch :e! wieder den Zustand herstellen, der existierte, als wir das letzte mal die Datei gespeichert haben. Wenn die Datei während des Editierens nicht gespeichert wurde, erhalten wir dadurch wieder den Zustand, in dem sich diese befand, als wir sie mit vi geöffnet haben.

3.) Wir stellen im Kommando-Modus (ESC-Taste) durch die u Taste (nur u, ohne ":"! ) den Zustand wieder her, der vor der letzten Eingabe, die wir im vi vorgenommen haben, existierte.

Der ex-Modus wird wieder verlassen, indem man entweder das dort eingegebene Kommando mit der Return-Taste bestätigt, oder, falls man versehentlich reingekommen ist, indem man alles in dieser Zeile mit der Backspace-Taste (oben rechts auf der Tastatur mit einem Pfeil nach links) entfernt. Damit ist man wieder im Kommando-Modus.

Kurzzusammenfassung

Editiere Datei

vi <Dateiname>

Verlasse Datei und speichere die bisherige Eingabe

ESC-Taste (Befehlsmodus)
ZZ oder :wq

Verlasse Datei aber speichere die bisherige Eingabe nicht

ESC-Taste (Befehlsmodus)
:q!

Wurde noch nichts an der Datei verändert, so genügt

:q

Bleibe in der zu editierenden Datei aber stelle den ursprünglichen Zustand wieder her

ESC-Taste (Befehlsmodus)
:e!

Bleibe in der zu editierenden Datei und mache die zuletzt vorgenommene Eingabe rückgängig

ESC-Taste (Befehlsmodus)
u oder :u

Dateien bearbeiten

Nachdem wir wissen, wie wir mit dem vi eine neue Datei anlegen können, wollen wir natürlich auch wissen, wie Änderungen in Textdateien vorgenommen werden können, da dies wahrscheinlich unsere Hauptaktivität mit einem Texteditor sein wird.

Nachdem wir mit

vi programm.c

wieder den Text geladen haben, erscheint beispielsweise:

# Hallo-Welt-Beispiel
puts "Hallo Welt"

Wenn wir jetzt unser Programm noch erweitern wollen, müssen wir neue Zeilen (irgendwo) einfügen. Hierzu begeben wir uns mit den normalen Cursor-Tasten (es gibt auch die Möglichkeit anstatt der Pfeil-Cursor-Tasten Buchstaben als Cursor-Tasten zu benutzen, doch dazu später) in die Zeile mit 'puts "Hallo Welt"'

Zum Einfügen von Zeilen gibt es im Kommandomodus die Buchstaben o oder O (wie engl. open). Ein kleines o fügt eine neue Zeile nach der aktuellen Zeile ein - du kannst dort einen beliebigen neuen Text verfassen. Wenn man fertig mit dem Einfügen ist, braucht man nur die ESC-Taste zu drücken um sich wieder im Kommando-Modus zu befinden. Das Pendant zum kleinen o ist ein großes O, das eine neue Zeile oberhalb der aktuellen Zeile einfügt.

Das Löschen von Zeilen geschieht durch Tippen von dd (ja, zwei d), was für delete steht. Dies löscht die aktuelle Zeile.

Zum Einfügen von zusätzlichen Zeichen an einer bestimmten Stelle in einer Zeile, navigiere an die gewünschte Position und drücke i, dies fügt Text vor der aktuellen Cursor-Position ein (Wechsel in den Bearbeitungsmodus) - wenn fertig, ESC drücken (Rückwechsel in den Kommandomodus).

Um an der aktuellen Cursorposition ein Zeichen zu löschen, tippe x.

So, das war schon der "Grundwortschatz", mit dem du alles im vi machen kannst, was du brauchst. Mehr musst du für den Anfang überhaupt nicht wissen.

Alles folgende dient dazu, dir das Leben mit vi zu vereinfachen.

vi für Power-User

Während der vi von vielen Anfängern als „Zumutung“ empfunden wird, findet man auch zahlreiche Power-User, die damit scheinbar „zaubern“ können. Die folgenden Abschnitte versuchen zu zeigen, woher dies kommt. Ziel ist allerdings nicht, eine brauchbare oder gar vollständige Befehls-Referenz vorzustellen. Vielmehr geht es ausschließlich darum, anhand typischer Szenarien zu demonstrieren, wo eine „Anpassung“ der mit anderen Editoren eingeübten Gewohnheiten nötig ist, um in den Genuss der Effizienz-Vorteile des vi zu kommen.

Alternative Sicht der Modi

Eine weniger verbreitete, alternative Sichtweise ist die, dass vi keinen besonderen „Einfüge-Modus“ hat, sondern

dass es eine Reihe von Befehlen gibt, wie i, a, cw ...,
denen unmittelbar eine Texteingabe folgen muss,
welche wiederum mit [ESC] abzuschließen ist.

Dass diese Sicht der Dinge - auch wenn sie ungewöhnlich ist - etwas für sich hat, zeigt sich spätestens dann, wenn man einem vi „Power-User“ über die Schulter sieht: Dieser wird nicht nur i und R sondern

mindestens ein halbes Dutzend unterschiedlicher Befehle benutzen, um eine Textänderung einzuleiten, und
in der Regel sofort im Anschluss an jede Texteingabe wieder [ESC] drücken.

Somit besteht nie ein Zweifel, ob vi sich denn nun im „Eingabe-Modus“ oder im „Befehls-Modus“ befindet: sieht man [ESC] als verpflichtenden abschließenden Bestandteil einer Texteingabe bzw. Änderung, gilt immer der Befehls-Modus und niemals wird versehentlich eine als Befehl gedachte Tastenfolge im editierten Text landen.

Textänderungen richtig einleiten

Obiges ist in der Praxis aber nur der kleinere Vorteil, sehr viel effizienzfördernder ist die Wahl des für den jeweiligen Zweck „richtigen“ Befehls zur Einleitung einer Textänderung. Als Eselsbrücke sollte man sich dabei merken, dass es sich bei vielen Befehlen um den Anfangsbuchstaben des entsprechenden Befehles in englischer Sprache handelt, so zum Beispiel i für insert, a für append oder o für open. Kleinbuchstaben bezeichnen dabei meist die aktuelle Cursorposition, Großbuchstaben bis Zeilenende, letzteres allerdings nicht immer. (Beispiel: D (für delete) bedeutet Löschen von aktueller Cursorposition bis zum Zeilenende.)

Die folgenden Tabelle ist zwar unvollständig, zeigt aber eine praxisrelevante Auswahl:

`i` / `a`	einfügen vor / hinter Cursor
`I` / `A`	am Zeilenanfang / Zeilenende ein-/anfügen
`o` / `O`	neue Zeile unter / über Cursor
`S` / `C`	gesamte Zeile / Zeile ab Cursor bis Ende ersetzen
`cw` / `ct`x	ab Cursor bis Wortende / bis zum Zeichen x ersetzen

(Im letzten Fall ist das Zeichen x frei wählbar, muss aber in der selben Zeile auftreten.)

Die höhere Arbeitsgeschwindigkeit resultiert vor allem daraus, dass man

vor der Änderung oft die Cursor-Positionierung spart und
nach der Änderung keine überschüssige Zeichen löschen muss, bzw.
während der Änderung kein Umschalten von „Überschreiben“ auf „Einfügen“ nötig ist.

Mit Absicht wurde in der obigen Tabelle übrigens auf den R-Befehl verzichtet, den vi-Neulinge wahrscheinlich als „Überschreibe-Modus“ kennen und nutzen: Es kommt in der Praxis gar nicht so oft vor, dass „1:1“ Zeichen zu ersetzen sind. Viel häufiger ist es dagegen erforderlich, ein gesamtes Wort oder z.B. alle Worte bis zum nächsten Komma zu überschreiben. Dann aber sind cw und ct, sehr viel praktischer, da man diese Befehle unabhängig davon verwenden kann, ob der neue Text länger oder kürzer ist: Es passiert stets genau das Richtige, d.h. es werden automatisch zusätzliche Zeichen eingefügt oder überschüssige gelöscht (wenn der Ersatztext exakt dieselbe Länge hat, funktioniert dies natürlich auch).

Sehr nützlich: Letzte Änderung wiederholen

Ein auf den ersten Blick unscheinbarer, für den Power-User aber unverzichtbarer Befehl ist das Punkt-Kommando (.), welches die letzte Veränderung am Text wiederholt - typischerweise natürlich an anderer Stelle. Das Anhängen einer schließenden Klammer und eines Semikolon an die aktuelle Zeile sowie die drei nachfolgenden Zeilen erfordert mit A);[ESC]j.j.j. nur ganze 10 Tastendrücke (und keinen einzigen Griff zur Maus) - man versuche diese Vorgabe mit scheinbar „komfortableren“ Editoren zu schlagen! Dabei spielt es keine Rolle,

wo der Cursor ursprünglich in der ersten zu ändernden Zeile stand, und
welche Länge die insgesamt vier betroffenen Zeilen haben.

(Der A-Befehl hängt stets am Ende der aktuellen Zeile an, egal wo der Cursor steht und wie lang die Zeile ist, j geht eine Zeile nach unten und . wiederholt die letzte Veränderung - also das Anhängen der Klammer und des Semikolons.)

Die Möglichkeit, die letzte Änderung mittels . zu wiederholen funktioniert auch für Befehle mit löschender Wirkung: Mehrere aufeinanderfolgende Worte oder Zeilen werden am schnellsten mit dw... bzw. dd... entfernt.

Alternativ ist es möglich, vor dem jeweiligen Kommando eine Zahl anzugeben, welche vi mitteilt, wie oft das Kommando ausgeführt werden soll. So löscht etwas 3dw die drei folgenden Worte oder 3dd drei Zeilen.

Kommando-Systematik verstehen

Der in der obigen Tabelle zuletzt gezeigte Befehl (c) ist insofern besonders interessant, als er mit vielen anderen vi-Befehlen kombiniert werden kann. Dazu wieder einige ausgewählte Beispiele, die nur das Prinzip verdeutlichen sollen. (Dabei bedeuten zum besseren Verständis z.B.: f (für find) einzelnes Zeichen finden, c (für change) Text ändern, y (für yank) Text in einen Puffer kopieren und p (für put) Text aus Puffer einfügen.)

`t,`	Cursor vor das nächste Komma in der laufenden Zeile setzen
`ct,`	Änderung einleiten, die sich bis vor das Komma erstreckt
`2f(`	Cursor auf übernächste, öffnende Klammer setzen
`c2f(`	Änderung einleiten vom Cursor bis inklusive übernächster Klammer

Im Fall von Veränderungen (c) ist die Eingabe wie Eingangs dargestellt durch [ESC] abzuschließen.

Kurzum, die vielfältigen vi-Befehle zur Cursor-Positionierung lassen sich somit alle nach c einsetzen, um den zu ändernden Bereich anzugeben!

Aber das ist noch nicht alles, denn auch andere Kommandos lassen sich mit Befehlen zur Cursor-Positionierung kombinieren. Hier nur einige wenige Beispiele:

`dt,`	löscht vom Cursor bis zum nächsten Komma (ohne das Komma)
`yt,`	kopiert vom Cursor bis zum nächsten Komma in einen Zwischenspeicher
`d2f(`	löscht vom Cursor bis zur übernächsten Klammer (inklusive Klammer)
`y2f(`	wie zuvor aber kein Löschen sondern Kopieren

(Der von y gefüllte Puffer oder Zwischenspeicher lässt sich mit den Befehlen p oder P an anderer Stelle wieder eingefügen.)

Da w für sich alleine den Cursor auf das nächste Wort setzt (mit w (für word) ist hier Wortanfang gemeint), sind wortweise wirkende Befehle wie cw, dw und yw also nur Sonderfälle einer allgemeineren Systematik. Wer diese einmal verstanden hat, wird sich nicht mehr wundern, warum nach dG alle Zeilen bis zum Dateiende verschwinden. Dabei bedeutet d (wie delete) wieder löschen und G (wie GoTo) ist ein Sprungbefehl. G mit Zahl x davor bedeutet Sprung zur Zeile x, als 1G heißt Sprung zur ersten Zeile und G ohne Zahl Sprung zum Datei-Ende.

Prinzip der Modularität

Eine andere Stärke des vi liegt darin, dass er - anders als manche vergleichbaren Werkzeuge - im Laufe der Zeit nicht zur „eierlegenden Wollmilchsau“ ausgebaut wurde, sondern stets die Zusammenarbeit mit vorhandenen Werkzeugen das Ziel war. Dieses Prinzip der Kombination von einfachen Befehlen zu komplexen Kommandos wird auch als Unix-Werkzeugkasten bezeichnet. So sind Unix/Linux u.a. für zahlreiche Programme bekannt, die textbasierte Aufgaben erledigen, sehr spezielle wie sort (Sortieren von Dateien), nl (Nummerieren von Zeilen) oder cb (Neuformatieren von C-Quelltexten), aber auch recht allgemeine wie sed oder awk.

Anstatt ähnliches im vi erneut zu implementieren, erlaubt dieser Editor mit dem !-Befehl die Anwendung beliebiger externer Programme auf den editierten Text. Auch hier zur Verdeutlichung nur wenige Beispiele:

`1,$!cb`	gesamte Datei (als C-Quelltext) neu formatieren
`12,20!sort`	Zeilen 12 bis 20 aufsteigend sortieren
`?BEGIN?,/END/!nl -ba`	Bereich zwischen den Zeilen, welche die Worte `BEGIN` und `END` enthalten, durchnumerieren

Der hier verwendete !-Befehl wird auch „Filter“ genannt, weil damit nicht nur Zeilen des editierten Textes an beliebige externe Kommandos gesendet, sondern deren Ausgabe auch wieder aufgefangen und in den editierten Text eingesetzt wird.

Gegenüber vergleichbaren, „eingebauten“ Features ergibt sich zum einen der Vorteil, dass man beliebige Werkzeuge einsetzen kann (zum Neuformatieren von C/C++ also z.B. auch indent, astyle, ...). Insbesondere aber lässt sich wirklich alles, das auf irgend eine Art und Weise mit Hilfe externer Programme machbar ist, auch direkt mit vi erledigen, etwa das:

.,/^$/-1!nl -ba | sort -k1rn | cut -c8-

Alles was vor dem ! steht ist eine zeilenweise Adressierung im vi, alles was danach kommt sind Unix-Kommandos (hier nl, sort und cut), die hier durch eine Pipeline miteinander verbunden sind. Das bedeutet zum Beispiel, dass die Ausgabe des sort-Kommandos als Eingabe für das cut-Kommando dient. Hinter den einzelnen Unix-Kommandos stehen noch Optionen, die die Arbeitsweise des jeweiligen Programmes beeinflussen.

Diese Kommando-Sequenz lässt sich also wie folgt erklären: Der Text ab der aktuellen Zeile (.) bis zur nächsten Leerzeile (/^$/), jedoch ohne diese (-1), erhält zunächst fortlaufende Zeilennummern (nl -ba). Die nummerierten Zeilen gehen weiter per Pipeline (|) und werden gemäß der gerade hinzugefügten Nummer absteigend sortiert (sort -k1rn). Schließlich folgt ein dritter Schritt, der die Zeilennummern wieder entfernt (cut -c8-).

Somit wird hier die Reihenfolge der Zeilen im angegebenen Bereichs umgedreht, die letzte wird zur ersten, die vorletzte zur zweiten usw. Insgesamt ist dies ein Paradebeispiel dafür, dass ein Werkzeug, welches sich ganz universell mit vielen anderen kombinieren lässt, auch von „leistungsfähigerer“ Konkurrenz kaum zu übertreffen ist.

Keine Panik

Sicher ist schon mehr als ein vi-Neuling in Panik verfallen, weil dieser „editor from hell“ plötzlich Dinge als Kommando interpretierte, die eigentlich als Texteingabe gedacht waren. Hier hatte der vi zugegebenermaßen eine Schwäche, da man mit u (u für undo) nur die letzte Änderung zurücknehmen kann. Heute werden die meisten vi-Benutzer wahrscheinlich unter Linux arbeiten und - mitunter unwissentlich - überhaupt nicht das Original, sondern den modernen „Klon“ Vim verwenden. Dieser erlaubt es standardmäßig bis zu 1000 Änderungen rückgängig zu machen, oder auch mit STRG-R (r für redo) erneut anzuwenden.

(Das 1000-fache Undo ist eine der wenigen Standard-Einstellungen, in denen Vim vom Original abweicht. Im Allgemeinen werden aber selbst erfahrene vi-Benutzer den Unterschied zum vim fast nicht bemerken - und wer beim Editieren niemals zwei Fehler hintereinander macht, kann auch im vim die Anzahl der Undo-Levels auf den Wert 1 reduzieren.

Mnemonik und Eselsbrücken

Durch die (auch vom Vim erfüllte) Zielvorgabe, dass der Editor ohne Maus und Sondertasten benutzbar sein soll, andererseits die Editierbefehle aber kurz bleiben müssen (praktisch alles Wichtige ist mit ein bis zwei Tastendrücken zu erledigen, nur für seltenere Dinge wie etwa „Verwerfen aller erfolgten Änderungen“ braucht man auch schon mal vier) ergibt sich zwangsläufig eine mangelhafte Mnemonik. Dennoch existieren häufig Eselsbrücken und so manches ist konsistenter, als es auf den ersten Blick scheint.

So wirken, wie oben bereits erwähnt, z.B. einige ähnliche Kommandos wie o und O (hier o für open) oder p und P (p für put) als Kleinbuchstabe unterhalb der aktuellen Zeile und als Großbuchstabe oberhalb (Merkhilfe: für Großbuchstaben braucht man die Shift-Taste, die i.d.R. mit einem breiten Pfeil nach oben gekennzeichnet ist.) Die erwähnte Systematik gilt auch für das Suchen von Textstellen mit / (nach unten) und ? (nach oben), aber leider nur auf US-Tastaturen - nur dort liegt / auf derselben Taste, die mit Shift ein ? erzeugt.

siehe auch

vi-Befehlsreferenz
Selflinux Vim-Tutorial